2013-05-29 01:46:57 +04:00
|
|
|
<?php
|
|
|
|
/**
|
|
|
|
* Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
|
|
|
|
* This file is licensed under the Affero General Public License version 3 or
|
|
|
|
* later.
|
|
|
|
* See the COPYING-README file.
|
|
|
|
*/
|
|
|
|
|
|
|
|
namespace Test\User;
|
|
|
|
|
2016-12-05 22:57:15 +03:00
|
|
|
use OC\AppFramework\Http\Request;
|
2016-10-10 14:59:55 +03:00
|
|
|
use OC\Authentication\Token\DefaultTokenMapper;
|
|
|
|
use OC\Authentication\Token\DefaultTokenProvider;
|
2016-09-12 22:53:21 +03:00
|
|
|
use OC\Authentication\Token\IProvider;
|
|
|
|
use OC\Authentication\Token\IToken;
|
2016-07-20 19:36:15 +03:00
|
|
|
use OC\Security\Bruteforce\Throttler;
|
2014-10-13 18:31:26 +04:00
|
|
|
use OC\Session\Memory;
|
2019-07-28 21:46:01 +03:00
|
|
|
use OC\User\Events\PostLoginEvent;
|
2016-09-12 22:53:21 +03:00
|
|
|
use OC\User\Manager;
|
|
|
|
use OC\User\Session;
|
2014-10-13 18:31:26 +04:00
|
|
|
use OC\User\User;
|
2016-12-05 22:57:15 +03:00
|
|
|
use OCA\DAV\Connector\Sabre\Auth;
|
2016-09-12 22:53:21 +03:00
|
|
|
use OCP\AppFramework\Utility\ITimeFactory;
|
2019-07-28 21:46:01 +03:00
|
|
|
use OCP\EventDispatcher\IEventDispatcher;
|
2016-09-12 22:53:21 +03:00
|
|
|
use OCP\IConfig;
|
2016-10-10 14:59:55 +03:00
|
|
|
use OCP\ILogger;
|
2016-09-12 22:53:21 +03:00
|
|
|
use OCP\IRequest;
|
|
|
|
use OCP\ISession;
|
|
|
|
use OCP\IUser;
|
2017-02-17 17:40:20 +03:00
|
|
|
use OCP\Lockdown\ILockdownManager;
|
2016-10-10 14:59:55 +03:00
|
|
|
use OCP\Security\ICrypto;
|
2016-09-12 22:53:21 +03:00
|
|
|
use OCP\Security\ISecureRandom;
|
2019-07-28 21:46:01 +03:00
|
|
|
use PHPUnit\Framework\MockObject\MockObject;
|
2019-02-22 15:07:26 +03:00
|
|
|
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
|
2014-10-13 18:31:26 +04:00
|
|
|
|
2016-01-04 17:05:28 +03:00
|
|
|
/**
|
|
|
|
* @group DB
|
|
|
|
* @package Test\User
|
|
|
|
*/
|
2016-05-20 16:38:20 +03:00
|
|
|
class SessionTest extends \Test\TestCase {
|
2019-07-28 21:46:01 +03:00
|
|
|
/** @var ITimeFactory|MockObject */
|
2016-05-02 20:58:19 +03:00
|
|
|
private $timeFactory;
|
2019-07-28 21:46:01 +03:00
|
|
|
/** @var DefaultTokenProvider|MockObject */
|
2016-06-03 09:55:00 +03:00
|
|
|
protected $tokenProvider;
|
2019-07-28 21:46:01 +03:00
|
|
|
/** @var IConfig|MockObject */
|
2016-05-24 15:08:42 +03:00
|
|
|
private $config;
|
2019-07-28 21:46:01 +03:00
|
|
|
/** @var Throttler|MockObject */
|
2016-07-20 19:36:15 +03:00
|
|
|
private $throttler;
|
2019-07-28 21:46:01 +03:00
|
|
|
/** @var ISecureRandom|MockObject */
|
2016-10-31 11:36:55 +03:00
|
|
|
private $random;
|
2019-07-28 21:46:01 +03:00
|
|
|
/** @var Manager|MockObject */
|
2016-11-02 15:37:39 +03:00
|
|
|
private $manager;
|
2019-07-28 21:46:01 +03:00
|
|
|
/** @var ISession|MockObject */
|
2016-11-02 15:37:39 +03:00
|
|
|
private $session;
|
2019-07-28 21:46:01 +03:00
|
|
|
/** @var Session|MockObject */
|
2016-11-02 15:37:39 +03:00
|
|
|
private $userSession;
|
2019-07-28 21:46:01 +03:00
|
|
|
/** @var ILockdownManager|MockObject */
|
2017-02-17 17:40:20 +03:00
|
|
|
private $lockdownManager;
|
2019-07-28 21:46:01 +03:00
|
|
|
/** @var ILogger|MockObject */
|
2018-01-23 11:58:46 +03:00
|
|
|
private $logger;
|
2019-07-28 21:46:01 +03:00
|
|
|
/** @var IEventDispatcher|MockObject */
|
|
|
|
private $dispatcher;
|
2016-05-24 15:08:42 +03:00
|
|
|
|
2016-04-28 11:52:28 +03:00
|
|
|
protected function setUp() {
|
|
|
|
parent::setUp();
|
2013-05-29 01:46:57 +04:00
|
|
|
|
2016-09-12 22:53:21 +03:00
|
|
|
$this->timeFactory = $this->createMock(ITimeFactory::class);
|
2016-05-02 20:58:19 +03:00
|
|
|
$this->timeFactory->expects($this->any())
|
|
|
|
->method('getTime')
|
|
|
|
->will($this->returnValue(10000));
|
2016-09-12 22:53:21 +03:00
|
|
|
$this->tokenProvider = $this->createMock(IProvider::class);
|
|
|
|
$this->config = $this->createMock(IConfig::class);
|
|
|
|
$this->throttler = $this->createMock(Throttler::class);
|
2016-10-31 11:36:55 +03:00
|
|
|
$this->random = $this->createMock(ISecureRandom::class);
|
2018-01-23 11:58:46 +03:00
|
|
|
$this->manager = $this->createMock(Manager::class);
|
2016-11-02 15:37:39 +03:00
|
|
|
$this->session = $this->createMock(ISession::class);
|
2017-02-17 17:40:20 +03:00
|
|
|
$this->lockdownManager = $this->createMock(ILockdownManager::class);
|
2018-01-23 11:58:46 +03:00
|
|
|
$this->logger = $this->createMock(ILogger::class);
|
2019-07-28 21:46:01 +03:00
|
|
|
$this->dispatcher = $this->createMock(IEventDispatcher::class);
|
2016-11-02 15:37:39 +03:00
|
|
|
$this->userSession = $this->getMockBuilder(Session::class)
|
|
|
|
->setConstructorArgs([
|
|
|
|
$this->manager,
|
|
|
|
$this->session,
|
|
|
|
$this->timeFactory,
|
|
|
|
$this->tokenProvider,
|
|
|
|
$this->config,
|
|
|
|
$this->random,
|
2018-01-23 11:58:46 +03:00
|
|
|
$this->lockdownManager,
|
|
|
|
$this->logger,
|
2019-07-28 21:46:01 +03:00
|
|
|
$this->dispatcher
|
2016-11-02 15:37:39 +03:00
|
|
|
])
|
|
|
|
->setMethods([
|
|
|
|
'setMagicInCookie',
|
|
|
|
])
|
|
|
|
->getMock();
|
2016-09-06 22:41:15 +03:00
|
|
|
|
|
|
|
\OC_User::setIncognitoMode(false);
|
2013-05-29 01:46:57 +04:00
|
|
|
}
|
|
|
|
|
2016-04-28 11:52:28 +03:00
|
|
|
public function testGetUser() {
|
|
|
|
$token = new \OC\Authentication\Token\DefaultToken();
|
2016-05-24 11:50:18 +03:00
|
|
|
$token->setLoginName('User123');
|
2016-06-20 10:10:11 +03:00
|
|
|
$token->setLastCheck(200);
|
2016-04-28 11:52:28 +03:00
|
|
|
|
2016-09-12 22:53:21 +03:00
|
|
|
$expectedUser = $this->createMock(IUser::class);
|
2016-05-24 11:50:18 +03:00
|
|
|
$expectedUser->expects($this->any())
|
|
|
|
->method('getUID')
|
|
|
|
->will($this->returnValue('user123'));
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->getMockBuilder(Memory::class)->setConstructorArgs([''])->getMock();
|
2016-04-28 11:52:28 +03:00
|
|
|
$session->expects($this->at(0))
|
2014-12-16 21:07:14 +03:00
|
|
|
->method('get')
|
|
|
|
->with('user_id')
|
2016-04-28 11:52:28 +03:00
|
|
|
->will($this->returnValue($expectedUser->getUID()));
|
2016-05-06 17:31:40 +03:00
|
|
|
$sessionId = 'abcdef12345';
|
2014-12-16 21:07:14 +03:00
|
|
|
|
2016-04-28 11:52:28 +03:00
|
|
|
$manager = $this->getMockBuilder('\OC\User\Manager')
|
|
|
|
->disableOriginalConstructor()
|
|
|
|
->getMock();
|
2016-06-20 10:10:11 +03:00
|
|
|
$session->expects($this->at(1))
|
|
|
|
->method('get')
|
|
|
|
->with('app_password')
|
|
|
|
->will($this->returnValue(null)); // No password set -> browser session
|
2016-05-06 17:31:40 +03:00
|
|
|
$session->expects($this->once())
|
|
|
|
->method('getId')
|
|
|
|
->will($this->returnValue($sessionId));
|
2016-06-03 09:55:00 +03:00
|
|
|
$this->tokenProvider->expects($this->once())
|
2016-04-28 11:52:28 +03:00
|
|
|
->method('getToken')
|
2016-06-20 10:10:11 +03:00
|
|
|
->with($sessionId)
|
2016-04-28 11:52:28 +03:00
|
|
|
->will($this->returnValue($token));
|
2016-06-03 09:55:00 +03:00
|
|
|
$this->tokenProvider->expects($this->once())
|
2016-04-28 11:52:28 +03:00
|
|
|
->method('getPassword')
|
2016-05-06 17:31:40 +03:00
|
|
|
->with($token, $sessionId)
|
2016-06-20 10:10:11 +03:00
|
|
|
->will($this->returnValue('passme'));
|
2016-04-28 11:52:28 +03:00
|
|
|
$manager->expects($this->once())
|
|
|
|
->method('checkPassword')
|
2016-06-20 10:10:11 +03:00
|
|
|
->with('User123', 'passme')
|
2016-05-24 11:50:18 +03:00
|
|
|
->will($this->returnValue(true));
|
|
|
|
$expectedUser->expects($this->once())
|
|
|
|
->method('isEnabled')
|
2014-12-16 21:07:14 +03:00
|
|
|
->will($this->returnValue(true));
|
|
|
|
|
2016-06-03 09:55:00 +03:00
|
|
|
$this->tokenProvider->expects($this->once())
|
2016-06-20 10:10:11 +03:00
|
|
|
->method('updateTokenActivity')
|
2016-04-28 11:52:28 +03:00
|
|
|
->with($token);
|
2014-12-16 21:07:14 +03:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
$manager->expects($this->once())
|
2016-04-28 11:52:28 +03:00
|
|
|
->method('get')
|
|
|
|
->with($expectedUser->getUID())
|
|
|
|
->will($this->returnValue($expectedUser));
|
|
|
|
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new \OC\User\Session($manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2016-04-28 11:52:28 +03:00
|
|
|
$user = $userSession->getUser();
|
|
|
|
$this->assertSame($expectedUser, $user);
|
2016-06-20 10:10:11 +03:00
|
|
|
$this->assertSame(10000, $token->getLastCheck());
|
2014-12-16 22:01:49 +03:00
|
|
|
}
|
2014-12-16 21:07:14 +03:00
|
|
|
|
2016-04-28 11:52:28 +03:00
|
|
|
public function isLoggedInData() {
|
|
|
|
return [
|
|
|
|
[true],
|
|
|
|
[false],
|
|
|
|
];
|
|
|
|
}
|
2014-12-16 22:01:49 +03:00
|
|
|
|
2016-04-28 11:52:28 +03:00
|
|
|
/**
|
|
|
|
* @dataProvider isLoggedInData
|
|
|
|
*/
|
|
|
|
public function testIsLoggedIn($isLoggedIn) {
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->getMockBuilder(Memory::class)->setConstructorArgs([''])->getMock();
|
2014-12-16 22:01:49 +03:00
|
|
|
|
2016-10-25 10:34:11 +03:00
|
|
|
$manager = $this->createMock(Manager::class);
|
2014-12-16 22:01:49 +03:00
|
|
|
|
2016-10-25 10:34:11 +03:00
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-04-28 11:52:28 +03:00
|
|
|
->setMethods([
|
|
|
|
'getUser'
|
|
|
|
])
|
|
|
|
->getMock();
|
2019-02-22 15:07:26 +03:00
|
|
|
$user = new User('sepp', null, $this->createMock(EventDispatcherInterface::class));
|
2016-04-28 11:52:28 +03:00
|
|
|
$userSession->expects($this->once())
|
|
|
|
->method('getUser')
|
|
|
|
->will($this->returnValue($isLoggedIn ? $user : null));
|
|
|
|
$this->assertEquals($isLoggedIn, $userSession->isLoggedIn());
|
2014-12-16 21:07:14 +03:00
|
|
|
}
|
|
|
|
|
2013-05-29 01:46:57 +04:00
|
|
|
public function testSetUser() {
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->getMockBuilder(Memory::class)->setConstructorArgs([''])->getMock();
|
2013-05-29 01:46:57 +04:00
|
|
|
$session->expects($this->once())
|
|
|
|
->method('set')
|
|
|
|
->with('user_id', 'foo');
|
|
|
|
|
2016-09-12 22:53:21 +03:00
|
|
|
$manager = $this->createMock(Manager::class);
|
2013-05-29 01:46:57 +04:00
|
|
|
|
2016-09-12 22:53:21 +03:00
|
|
|
$backend = $this->createMock(\Test\Util\User\Dummy::class);
|
2013-05-29 01:46:57 +04:00
|
|
|
|
2019-02-22 15:07:26 +03:00
|
|
|
$user = $this->createMock(IUser::class);
|
2013-05-29 01:46:57 +04:00
|
|
|
$user->expects($this->once())
|
|
|
|
->method('getUID')
|
|
|
|
->will($this->returnValue('foo'));
|
|
|
|
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new \OC\User\Session($manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2013-05-29 01:46:57 +04:00
|
|
|
$userSession->setUser($user);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function testLoginValidPasswordEnabled() {
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->getMockBuilder(Memory::class)->setConstructorArgs([''])->getMock();
|
2016-01-04 17:00:58 +03:00
|
|
|
$session->expects($this->once())
|
|
|
|
->method('regenerateId');
|
2016-06-20 10:10:11 +03:00
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
|
|
|
->with('bar')
|
2016-06-20 11:41:23 +03:00
|
|
|
->will($this->throwException(new \OC\Authentication\Exceptions\InvalidTokenException()));
|
2013-12-13 15:56:06 +04:00
|
|
|
$session->expects($this->exactly(2))
|
2013-05-29 01:46:57 +04:00
|
|
|
->method('set')
|
2014-10-13 18:31:26 +04:00
|
|
|
->with($this->callback(function ($key) {
|
2016-10-10 14:59:55 +03:00
|
|
|
switch ($key) {
|
|
|
|
case 'user_id':
|
|
|
|
case 'loginname':
|
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}, 'foo'));
|
2013-05-29 01:46:57 +04:00
|
|
|
|
2016-10-25 10:34:11 +03:00
|
|
|
$managerMethods = get_class_methods(Manager::class);
|
2016-09-06 22:41:15 +03:00
|
|
|
//keep following methods intact in order to ensure hooks are working
|
|
|
|
$mockedManagerMethods = array_diff($managerMethods, ['__construct', 'emit', 'listen']);
|
2016-10-31 11:36:55 +03:00
|
|
|
$manager = $this->getMockBuilder(Manager::class)
|
|
|
|
->setMethods($mockedManagerMethods)
|
2019-02-22 15:07:26 +03:00
|
|
|
->setConstructorArgs([$this->config, $this->createMock(EventDispatcherInterface::class)])
|
2016-10-28 10:07:40 +03:00
|
|
|
->getMock();
|
2013-05-29 01:46:57 +04:00
|
|
|
|
2016-09-12 22:53:21 +03:00
|
|
|
$backend = $this->createMock(\Test\Util\User\Dummy::class);
|
2013-05-29 01:46:57 +04:00
|
|
|
|
2019-02-22 15:07:26 +03:00
|
|
|
$user = $this->createMock(IUser::class);
|
2016-05-06 17:31:40 +03:00
|
|
|
$user->expects($this->any())
|
2013-05-29 01:46:57 +04:00
|
|
|
->method('isEnabled')
|
|
|
|
->will($this->returnValue(true));
|
|
|
|
$user->expects($this->any())
|
|
|
|
->method('getUID')
|
|
|
|
->will($this->returnValue('foo'));
|
2014-05-23 02:59:26 +04:00
|
|
|
$user->expects($this->once())
|
|
|
|
->method('updateLastLoginTimestamp');
|
2013-05-29 01:46:57 +04:00
|
|
|
|
|
|
|
$manager->expects($this->once())
|
2018-01-23 11:58:46 +03:00
|
|
|
->method('checkPasswordNoLogging')
|
2013-09-16 16:15:35 +04:00
|
|
|
->with('foo', 'bar')
|
2013-05-29 01:46:57 +04:00
|
|
|
->will($this->returnValue($user));
|
|
|
|
|
2016-10-25 10:34:11 +03:00
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-04-28 11:52:28 +03:00
|
|
|
->setMethods([
|
|
|
|
'prepareUserLogin'
|
|
|
|
])
|
|
|
|
->getMock();
|
|
|
|
$userSession->expects($this->once())
|
|
|
|
->method('prepareUserLogin');
|
2019-07-28 21:46:01 +03:00
|
|
|
|
|
|
|
$this->dispatcher->expects($this->once())
|
|
|
|
->method('dispatch')
|
|
|
|
->with(
|
|
|
|
PostLoginEvent::class,
|
|
|
|
$this->callback(function(PostLoginEvent $e) {
|
|
|
|
return $e->getUser()->getUID() === 'foo' &&
|
|
|
|
$e->getPassword() === 'bar' &&
|
|
|
|
$e->getIsTokenLogin() === false;
|
|
|
|
})
|
|
|
|
);
|
|
|
|
|
2013-05-29 01:46:57 +04:00
|
|
|
$userSession->login('foo', 'bar');
|
|
|
|
$this->assertEquals($user, $userSession->getUser());
|
|
|
|
}
|
|
|
|
|
2016-05-06 17:31:40 +03:00
|
|
|
/**
|
|
|
|
* @expectedException \OC\User\LoginException
|
|
|
|
*/
|
2013-05-29 01:46:57 +04:00
|
|
|
public function testLoginValidPasswordDisabled() {
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->getMockBuilder(Memory::class)->setConstructorArgs([''])->getMock();
|
2013-05-29 01:46:57 +04:00
|
|
|
$session->expects($this->never())
|
|
|
|
->method('set');
|
2016-01-04 17:00:58 +03:00
|
|
|
$session->expects($this->once())
|
2016-04-28 11:52:28 +03:00
|
|
|
->method('regenerateId');
|
2016-06-20 10:10:11 +03:00
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
|
|
|
->with('bar')
|
|
|
|
->will($this->throwException(new \OC\Authentication\Exceptions\InvalidTokenException()));
|
2013-05-29 01:46:57 +04:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
$managerMethods = get_class_methods(\OC\User\Manager::class);
|
|
|
|
//keep following methods intact in order to ensure hooks are working
|
|
|
|
$mockedManagerMethods = array_diff($managerMethods, ['__construct', 'emit', 'listen']);
|
2016-10-31 11:36:55 +03:00
|
|
|
$manager = $this->getMockBuilder(Manager::class)
|
|
|
|
->setMethods($mockedManagerMethods)
|
2019-02-22 15:07:26 +03:00
|
|
|
->setConstructorArgs([$this->config, $this->createMock(EventDispatcherInterface::class)])
|
2016-10-28 10:07:40 +03:00
|
|
|
->getMock();
|
2013-05-29 01:46:57 +04:00
|
|
|
|
2016-09-12 22:53:21 +03:00
|
|
|
$backend = $this->createMock(\Test\Util\User\Dummy::class);
|
2013-05-29 01:46:57 +04:00
|
|
|
|
2019-02-22 15:07:26 +03:00
|
|
|
$user = $this->createMock(IUser::class);
|
2016-05-06 17:31:40 +03:00
|
|
|
$user->expects($this->any())
|
2013-05-29 01:46:57 +04:00
|
|
|
->method('isEnabled')
|
|
|
|
->will($this->returnValue(false));
|
2014-05-23 02:59:26 +04:00
|
|
|
$user->expects($this->never())
|
|
|
|
->method('updateLastLoginTimestamp');
|
2013-05-29 01:46:57 +04:00
|
|
|
|
|
|
|
$manager->expects($this->once())
|
2018-01-23 11:58:46 +03:00
|
|
|
->method('checkPasswordNoLogging')
|
2013-09-16 16:15:35 +04:00
|
|
|
->with('foo', 'bar')
|
2013-05-29 01:46:57 +04:00
|
|
|
->will($this->returnValue($user));
|
|
|
|
|
2019-07-28 21:46:01 +03:00
|
|
|
$this->dispatcher->expects($this->never())
|
|
|
|
->method('dispatch');
|
|
|
|
|
|
|
|
$userSession = new \OC\User\Session($manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2013-05-29 01:46:57 +04:00
|
|
|
$userSession->login('foo', 'bar');
|
|
|
|
}
|
|
|
|
|
2016-01-04 17:00:58 +03:00
|
|
|
public function testLoginInvalidPassword() {
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->getMockBuilder(Memory::class)->setConstructorArgs([''])->getMock();
|
2016-09-06 22:41:15 +03:00
|
|
|
$managerMethods = get_class_methods(\OC\User\Manager::class);
|
|
|
|
//keep following methods intact in order to ensure hooks are working
|
|
|
|
$mockedManagerMethods = array_diff($managerMethods, ['__construct', 'emit', 'listen']);
|
2016-10-31 11:36:55 +03:00
|
|
|
$manager = $this->getMockBuilder(Manager::class)
|
|
|
|
->setMethods($mockedManagerMethods)
|
2019-02-22 15:07:26 +03:00
|
|
|
->setConstructorArgs([$this->config, $this->createMock(EventDispatcherInterface::class)])
|
2016-10-28 10:07:40 +03:00
|
|
|
->getMock();
|
2016-09-12 22:53:21 +03:00
|
|
|
$backend = $this->createMock(\Test\Util\User\Dummy::class);
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new \OC\User\Session($manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2013-05-29 01:46:57 +04:00
|
|
|
|
2019-02-22 15:07:26 +03:00
|
|
|
$user = $this->createMock(IUser::class);
|
2016-06-20 10:10:11 +03:00
|
|
|
|
|
|
|
$session->expects($this->never())
|
|
|
|
->method('set');
|
|
|
|
$session->expects($this->once())
|
|
|
|
->method('regenerateId');
|
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
|
|
|
->with('bar')
|
|
|
|
->will($this->throwException(new \OC\Authentication\Exceptions\InvalidTokenException()));
|
|
|
|
|
2013-05-29 01:46:57 +04:00
|
|
|
$user->expects($this->never())
|
|
|
|
->method('isEnabled');
|
2014-05-23 02:59:26 +04:00
|
|
|
$user->expects($this->never())
|
|
|
|
->method('updateLastLoginTimestamp');
|
2013-05-29 01:46:57 +04:00
|
|
|
|
|
|
|
$manager->expects($this->once())
|
2018-01-23 11:58:46 +03:00
|
|
|
->method('checkPasswordNoLogging')
|
2013-09-16 16:15:35 +04:00
|
|
|
->with('foo', 'bar')
|
|
|
|
->will($this->returnValue(false));
|
2013-05-29 01:46:57 +04:00
|
|
|
|
2019-07-28 21:46:01 +03:00
|
|
|
$this->dispatcher->expects($this->never())
|
|
|
|
->method('dispatch');
|
|
|
|
|
2013-05-29 01:46:57 +04:00
|
|
|
$userSession->login('foo', 'bar');
|
|
|
|
}
|
|
|
|
|
|
|
|
public function testLoginNonExisting() {
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->getMockBuilder(Memory::class)->setConstructorArgs([''])->getMock();
|
|
|
|
$manager = $this->createMock(Manager::class);
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new \OC\User\Session($manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2016-06-20 10:10:11 +03:00
|
|
|
|
2013-05-29 01:46:57 +04:00
|
|
|
$session->expects($this->never())
|
|
|
|
->method('set');
|
2016-01-04 17:00:58 +03:00
|
|
|
$session->expects($this->once())
|
2016-04-28 11:52:28 +03:00
|
|
|
->method('regenerateId');
|
2016-06-20 10:10:11 +03:00
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
|
|
|
->with('bar')
|
|
|
|
->will($this->throwException(new \OC\Authentication\Exceptions\InvalidTokenException()));
|
2016-04-28 11:52:28 +03:00
|
|
|
|
2013-05-29 01:46:57 +04:00
|
|
|
$manager->expects($this->once())
|
2018-01-23 11:58:46 +03:00
|
|
|
->method('checkPasswordNoLogging')
|
2013-09-16 16:15:35 +04:00
|
|
|
->with('foo', 'bar')
|
|
|
|
->will($this->returnValue(false));
|
2013-05-29 01:46:57 +04:00
|
|
|
|
|
|
|
$userSession->login('foo', 'bar');
|
|
|
|
}
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-06-24 14:57:09 +03:00
|
|
|
/**
|
|
|
|
* When using a device token, the loginname must match the one that was used
|
|
|
|
* when generating the token on the browser.
|
|
|
|
*/
|
|
|
|
public function testLoginWithDifferentTokenLoginName() {
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->getMockBuilder(Memory::class)->setConstructorArgs([''])->getMock();
|
|
|
|
$manager = $this->createMock(Manager::class);
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new \OC\User\Session($manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2016-06-24 14:57:09 +03:00
|
|
|
$username = 'user123';
|
|
|
|
$token = new \OC\Authentication\Token\DefaultToken();
|
|
|
|
$token->setLoginName($username);
|
|
|
|
|
|
|
|
$session->expects($this->never())
|
|
|
|
->method('set');
|
|
|
|
$session->expects($this->once())
|
|
|
|
->method('regenerateId');
|
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
|
|
|
->with('bar')
|
|
|
|
->will($this->returnValue($token));
|
|
|
|
|
|
|
|
$manager->expects($this->once())
|
2018-01-23 11:58:46 +03:00
|
|
|
->method('checkPasswordNoLogging')
|
2016-06-24 14:57:09 +03:00
|
|
|
->with('foo', 'bar')
|
|
|
|
->will($this->returnValue(false));
|
|
|
|
|
|
|
|
$userSession->login('foo', 'bar');
|
|
|
|
}
|
|
|
|
|
2016-06-17 12:01:35 +03:00
|
|
|
/**
|
|
|
|
* @expectedException \OC\Authentication\Exceptions\PasswordLoginForbiddenException
|
|
|
|
*/
|
2016-05-24 15:08:42 +03:00
|
|
|
public function testLogClientInNoTokenPasswordWith2fa() {
|
2016-10-25 10:34:11 +03:00
|
|
|
$manager = $this->createMock(Manager::class);
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$request = $this->createMock(IRequest::class);
|
2016-05-24 15:08:42 +03:00
|
|
|
|
|
|
|
/** @var \OC\User\Session $userSession */
|
2016-10-25 10:34:11 +03:00
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-06-13 17:00:49 +03:00
|
|
|
->setMethods(['login', 'supportsCookies', 'createSessionToken', 'getUser'])
|
2016-05-24 15:08:42 +03:00
|
|
|
->getMock();
|
|
|
|
|
2016-06-03 09:55:00 +03:00
|
|
|
$this->tokenProvider->expects($this->once())
|
2016-05-24 15:08:42 +03:00
|
|
|
->method('getToken')
|
|
|
|
->with('doe')
|
|
|
|
->will($this->throwException(new \OC\Authentication\Exceptions\InvalidTokenException()));
|
|
|
|
$this->config->expects($this->once())
|
|
|
|
->method('getSystemValue')
|
|
|
|
->with('token_auth_enforced', false)
|
|
|
|
->will($this->returnValue(true));
|
2016-07-20 19:36:15 +03:00
|
|
|
$request
|
2016-08-26 16:10:03 +03:00
|
|
|
->expects($this->any())
|
2016-07-20 19:36:15 +03:00
|
|
|
->method('getRemoteAddress')
|
|
|
|
->willReturn('192.168.0.1');
|
|
|
|
$this->throttler
|
|
|
|
->expects($this->once())
|
|
|
|
->method('sleepDelay')
|
|
|
|
->with('192.168.0.1');
|
2016-07-21 00:09:27 +03:00
|
|
|
$this->throttler
|
2016-08-26 16:10:03 +03:00
|
|
|
->expects($this->any())
|
2016-07-21 00:09:27 +03:00
|
|
|
->method('getDelay')
|
|
|
|
->with('192.168.0.1')
|
|
|
|
->willReturn(0);
|
2016-07-20 19:36:15 +03:00
|
|
|
|
|
|
|
$userSession->logClientIn('john', 'doe', $request, $this->throttler);
|
2016-06-13 17:00:49 +03:00
|
|
|
}
|
|
|
|
|
2016-10-07 17:49:57 +03:00
|
|
|
public function testLogClientInUnexist() {
|
2016-10-25 10:34:11 +03:00
|
|
|
$manager = $this->createMock(Manager::class);
|
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$request = $this->createMock(IRequest::class);
|
2016-10-07 17:49:57 +03:00
|
|
|
|
2016-10-25 10:34:11 +03:00
|
|
|
/** @var Session $userSession */
|
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-10-07 17:49:57 +03:00
|
|
|
->setMethods(['login', 'supportsCookies', 'createSessionToken', 'getUser'])
|
|
|
|
->getMock();
|
|
|
|
|
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
|
|
|
->with('doe')
|
|
|
|
->will($this->throwException(new \OC\Authentication\Exceptions\InvalidTokenException()));
|
|
|
|
$this->config->expects($this->once())
|
|
|
|
->method('getSystemValue')
|
|
|
|
->with('token_auth_enforced', false)
|
|
|
|
->will($this->returnValue(false));
|
2017-08-09 17:13:54 +03:00
|
|
|
$manager->method('getByEmail')
|
|
|
|
->with('unexist')
|
|
|
|
->willReturn([]);
|
2016-10-07 17:49:57 +03:00
|
|
|
|
2016-10-25 10:34:11 +03:00
|
|
|
$this->assertFalse($userSession->logClientIn('unexist', 'doe', $request, $this->throttler));
|
2016-10-07 17:49:57 +03:00
|
|
|
}
|
|
|
|
|
2016-06-13 17:00:49 +03:00
|
|
|
public function testLogClientInWithTokenPassword() {
|
2016-10-25 10:34:11 +03:00
|
|
|
$manager = $this->createMock(Manager::class);
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$request = $this->createMock(IRequest::class);
|
2016-06-13 17:00:49 +03:00
|
|
|
|
|
|
|
/** @var \OC\User\Session $userSession */
|
2016-10-25 10:34:11 +03:00
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-06-13 17:00:49 +03:00
|
|
|
->setMethods(['isTokenPassword', 'login', 'supportsCookies', 'createSessionToken', 'getUser'])
|
|
|
|
->getMock();
|
|
|
|
|
|
|
|
$userSession->expects($this->once())
|
|
|
|
->method('isTokenPassword')
|
|
|
|
->will($this->returnValue(true));
|
|
|
|
$userSession->expects($this->once())
|
|
|
|
->method('login')
|
2016-06-20 10:10:11 +03:00
|
|
|
->with('john', 'I-AM-AN-APP-PASSWORD')
|
2016-06-13 17:00:49 +03:00
|
|
|
->will($this->returnValue(true));
|
|
|
|
|
2016-06-20 10:10:11 +03:00
|
|
|
$session->expects($this->once())
|
|
|
|
->method('set')
|
|
|
|
->with('app_password', 'I-AM-AN-APP-PASSWORD');
|
2016-07-20 19:36:15 +03:00
|
|
|
$request
|
2016-08-26 16:10:03 +03:00
|
|
|
->expects($this->any())
|
2016-07-20 19:36:15 +03:00
|
|
|
->method('getRemoteAddress')
|
|
|
|
->willReturn('192.168.0.1');
|
|
|
|
$this->throttler
|
|
|
|
->expects($this->once())
|
|
|
|
->method('sleepDelay')
|
|
|
|
->with('192.168.0.1');
|
2016-07-21 00:09:27 +03:00
|
|
|
$this->throttler
|
2016-08-26 16:10:03 +03:00
|
|
|
->expects($this->any())
|
2016-07-21 00:09:27 +03:00
|
|
|
->method('getDelay')
|
|
|
|
->with('192.168.0.1')
|
|
|
|
->willReturn(0);
|
2016-07-20 19:36:15 +03:00
|
|
|
|
|
|
|
$this->assertTrue($userSession->logClientIn('john', 'I-AM-AN-APP-PASSWORD', $request, $this->throttler));
|
2016-05-24 15:08:42 +03:00
|
|
|
}
|
|
|
|
|
2016-06-17 12:01:35 +03:00
|
|
|
/**
|
|
|
|
* @expectedException \OC\Authentication\Exceptions\PasswordLoginForbiddenException
|
|
|
|
*/
|
2016-05-24 15:08:42 +03:00
|
|
|
public function testLogClientInNoTokenPasswordNo2fa() {
|
2016-10-25 10:34:11 +03:00
|
|
|
$manager = $this->createMock(Manager::class);
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$request = $this->createMock(IRequest::class);
|
2016-05-24 15:08:42 +03:00
|
|
|
|
|
|
|
/** @var \OC\User\Session $userSession */
|
2016-10-25 10:34:11 +03:00
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-05-24 15:08:42 +03:00
|
|
|
->setMethods(['login', 'isTwoFactorEnforced'])
|
|
|
|
->getMock();
|
|
|
|
|
2016-06-03 09:55:00 +03:00
|
|
|
$this->tokenProvider->expects($this->once())
|
2016-05-24 15:08:42 +03:00
|
|
|
->method('getToken')
|
|
|
|
->with('doe')
|
|
|
|
->will($this->throwException(new \OC\Authentication\Exceptions\InvalidTokenException()));
|
|
|
|
$this->config->expects($this->once())
|
|
|
|
->method('getSystemValue')
|
|
|
|
->with('token_auth_enforced', false)
|
|
|
|
->will($this->returnValue(false));
|
|
|
|
|
|
|
|
$userSession->expects($this->once())
|
|
|
|
->method('isTwoFactorEnforced')
|
|
|
|
->with('john')
|
|
|
|
->will($this->returnValue(true));
|
|
|
|
|
2016-07-20 19:36:15 +03:00
|
|
|
$request
|
2016-08-26 16:10:03 +03:00
|
|
|
->expects($this->any())
|
2016-07-20 19:36:15 +03:00
|
|
|
->method('getRemoteAddress')
|
|
|
|
->willReturn('192.168.0.1');
|
|
|
|
$this->throttler
|
|
|
|
->expects($this->once())
|
|
|
|
->method('sleepDelay')
|
|
|
|
->with('192.168.0.1');
|
2016-07-21 00:09:27 +03:00
|
|
|
$this->throttler
|
2016-08-26 16:10:03 +03:00
|
|
|
->expects($this->any())
|
2016-07-21 00:09:27 +03:00
|
|
|
->method('getDelay')
|
|
|
|
->with('192.168.0.1')
|
|
|
|
->willReturn(0);
|
2016-07-20 19:36:15 +03:00
|
|
|
|
|
|
|
$userSession->logClientIn('john', 'doe', $request, $this->throttler);
|
2016-05-24 15:08:42 +03:00
|
|
|
}
|
|
|
|
|
2014-05-23 02:18:07 +04:00
|
|
|
public function testRememberLoginValidToken() {
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->getMockBuilder(Memory::class)->setConstructorArgs([''])->getMock();
|
2016-09-06 22:41:15 +03:00
|
|
|
$managerMethods = get_class_methods(\OC\User\Manager::class);
|
|
|
|
//keep following methods intact in order to ensure hooks are working
|
|
|
|
$mockedManagerMethods = array_diff($managerMethods, ['__construct', 'emit', 'listen']);
|
2016-10-31 11:36:55 +03:00
|
|
|
$manager = $this->getMockBuilder(Manager::class)
|
|
|
|
->setMethods($mockedManagerMethods)
|
2019-02-22 15:07:26 +03:00
|
|
|
->setConstructorArgs([$this->config, $this->createMock(EventDispatcherInterface::class)])
|
2016-10-31 11:36:55 +03:00
|
|
|
->getMock();
|
2016-09-06 22:41:15 +03:00
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
|
|
|
//override, otherwise tests will fail because of setcookie()
|
2017-01-05 14:16:50 +03:00
|
|
|
->setMethods(['setMagicInCookie', 'setLoginName'])
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-09-06 22:41:15 +03:00
|
|
|
->getMock();
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
$user = $this->createMock(IUser::class);
|
|
|
|
$token = 'goodToken';
|
|
|
|
$oldSessionId = 'sess321';
|
|
|
|
$sessionId = 'sess123';
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
$session->expects($this->once())
|
|
|
|
->method('regenerateId');
|
|
|
|
$manager->expects($this->once())
|
|
|
|
->method('get')
|
|
|
|
->with('foo')
|
|
|
|
->will($this->returnValue($user));
|
|
|
|
$this->config->expects($this->once())
|
|
|
|
->method('getUserKeys')
|
|
|
|
->with('foo', 'login_token')
|
|
|
|
->will($this->returnValue([$token]));
|
|
|
|
$this->config->expects($this->once())
|
|
|
|
->method('deleteUserValue')
|
|
|
|
->with('foo', 'login_token', $token);
|
2016-10-31 11:36:55 +03:00
|
|
|
$this->random->expects($this->once())
|
|
|
|
->method('generate')
|
|
|
|
->with(32)
|
|
|
|
->will($this->returnValue('abcdefg123456'));
|
2016-09-06 22:41:15 +03:00
|
|
|
$this->config->expects($this->once())
|
2016-10-31 11:36:55 +03:00
|
|
|
->method('setUserValue')
|
|
|
|
->with('foo', 'login_token', 'abcdefg123456', 10000);
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2017-01-05 14:16:50 +03:00
|
|
|
$tokenObject = $this->createMock(IToken::class);
|
|
|
|
$tokenObject->expects($this->once())
|
|
|
|
->method('getLoginName')
|
|
|
|
->willReturn('foobar');
|
2018-05-15 12:32:25 +03:00
|
|
|
$tokenObject->method('getId')
|
|
|
|
->willReturn(42);
|
2019-10-08 12:01:53 +03:00
|
|
|
|
|
|
|
$session->expects($this->once())
|
|
|
|
->method('getId')
|
|
|
|
->will($this->returnValue($sessionId));
|
2017-01-05 14:16:50 +03:00
|
|
|
$this->tokenProvider->expects($this->once())
|
2019-10-08 12:01:53 +03:00
|
|
|
->method('renewSessionToken')
|
|
|
|
->with($oldSessionId, $sessionId)
|
2017-01-05 14:16:50 +03:00
|
|
|
->willReturn($tokenObject);
|
|
|
|
|
2019-10-08 12:01:53 +03:00
|
|
|
$this->tokenProvider->expects($this->never())
|
|
|
|
->method('getToken');
|
|
|
|
|
2014-05-23 02:18:07 +04:00
|
|
|
$user->expects($this->any())
|
|
|
|
->method('getUID')
|
|
|
|
->will($this->returnValue('foo'));
|
2016-09-06 22:41:15 +03:00
|
|
|
$userSession->expects($this->once())
|
|
|
|
->method('setMagicInCookie');
|
2014-05-23 02:54:17 +04:00
|
|
|
$user->expects($this->once())
|
|
|
|
->method('updateLastLoginTimestamp');
|
2018-05-15 12:32:25 +03:00
|
|
|
$setUID = false;
|
|
|
|
$session
|
2016-09-06 22:41:15 +03:00
|
|
|
->method('set')
|
2018-05-15 12:32:25 +03:00
|
|
|
->will($this->returnCallback(function ($k, $v) use (&$setUID) {
|
|
|
|
if ($k === 'user_id' && $v === 'foo') {
|
|
|
|
$setUID = true;
|
|
|
|
}
|
|
|
|
}));
|
2017-01-05 14:16:50 +03:00
|
|
|
$userSession->expects($this->once())
|
|
|
|
->method('setLoginName')
|
|
|
|
->willReturn('foobar');
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
$granted = $userSession->loginWithCookie('foo', $token, $oldSessionId);
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2018-05-15 12:32:25 +03:00
|
|
|
$this->assertTrue($setUID);
|
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
$this->assertTrue($granted);
|
|
|
|
}
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
public function testRememberLoginInvalidSessionToken() {
|
|
|
|
$session = $this->getMockBuilder(Memory::class)->setConstructorArgs([''])->getMock();
|
|
|
|
$managerMethods = get_class_methods(\OC\User\Manager::class);
|
|
|
|
//keep following methods intact in order to ensure hooks are working
|
|
|
|
$mockedManagerMethods = array_diff($managerMethods, ['__construct', 'emit', 'listen']);
|
2016-10-31 11:36:55 +03:00
|
|
|
$manager = $this->getMockBuilder(Manager::class)
|
|
|
|
->setMethods($mockedManagerMethods)
|
2019-02-22 15:07:26 +03:00
|
|
|
->setConstructorArgs([$this->config, $this->createMock(EventDispatcherInterface::class)])
|
2016-10-31 11:36:55 +03:00
|
|
|
->getMock();
|
2016-09-12 22:53:21 +03:00
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
2014-05-23 02:18:07 +04:00
|
|
|
//override, otherwise tests will fail because of setcookie()
|
2016-09-12 22:53:21 +03:00
|
|
|
->setMethods(['setMagicInCookie'])
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-09-12 22:53:21 +03:00
|
|
|
->getMock();
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
$user = $this->createMock(IUser::class);
|
|
|
|
$token = 'goodToken';
|
|
|
|
$oldSessionId = 'sess321';
|
|
|
|
$sessionId = 'sess123';
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-01-04 17:00:58 +03:00
|
|
|
$session->expects($this->once())
|
2016-04-28 11:52:28 +03:00
|
|
|
->method('regenerateId');
|
2016-09-06 22:41:15 +03:00
|
|
|
$manager->expects($this->once())
|
|
|
|
->method('get')
|
|
|
|
->with('foo')
|
|
|
|
->will($this->returnValue($user));
|
|
|
|
$this->config->expects($this->once())
|
|
|
|
->method('getUserKeys')
|
|
|
|
->with('foo', 'login_token')
|
|
|
|
->will($this->returnValue([$token]));
|
|
|
|
$this->config->expects($this->once())
|
|
|
|
->method('deleteUserValue')
|
|
|
|
->with('foo', 'login_token', $token);
|
|
|
|
$this->config->expects($this->once())
|
|
|
|
->method('setUserValue'); // TODO: mock new random value
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
$session->expects($this->once())
|
|
|
|
->method('getId')
|
|
|
|
->will($this->returnValue($sessionId));
|
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('renewSessionToken')
|
|
|
|
->with($oldSessionId, $sessionId)
|
|
|
|
->will($this->throwException(new \OC\Authentication\Exceptions\InvalidTokenException()));
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
$user->expects($this->never())
|
2014-05-23 02:18:07 +04:00
|
|
|
->method('getUID')
|
|
|
|
->will($this->returnValue('foo'));
|
2016-09-06 22:41:15 +03:00
|
|
|
$userSession->expects($this->never())
|
|
|
|
->method('setMagicInCookie');
|
2014-05-23 02:54:17 +04:00
|
|
|
$user->expects($this->never())
|
|
|
|
->method('updateLastLoginTimestamp');
|
2016-09-06 22:41:15 +03:00
|
|
|
$session->expects($this->never())
|
|
|
|
->method('set')
|
|
|
|
->with('user_id', 'foo');
|
|
|
|
|
|
|
|
$granted = $userSession->loginWithCookie('foo', $token, $oldSessionId);
|
|
|
|
|
|
|
|
$this->assertFalse($granted);
|
|
|
|
}
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
public function testRememberLoginInvalidToken() {
|
|
|
|
$session = $this->getMockBuilder(Memory::class)->setConstructorArgs([''])->getMock();
|
|
|
|
$managerMethods = get_class_methods(\OC\User\Manager::class);
|
|
|
|
//keep following methods intact in order to ensure hooks are working
|
|
|
|
$mockedManagerMethods = array_diff($managerMethods, ['__construct', 'emit', 'listen']);
|
2016-10-31 11:36:55 +03:00
|
|
|
$manager = $this->getMockBuilder(Manager::class)
|
|
|
|
->setMethods($mockedManagerMethods)
|
2019-02-22 15:07:26 +03:00
|
|
|
->setConstructorArgs([$this->config, $this->createMock(EventDispatcherInterface::class)])
|
2016-10-31 11:36:55 +03:00
|
|
|
->getMock();
|
2016-09-06 22:41:15 +03:00
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
|
|
|
//override, otherwise tests will fail because of setcookie()
|
|
|
|
->setMethods(['setMagicInCookie'])
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-09-06 22:41:15 +03:00
|
|
|
->getMock();
|
|
|
|
|
|
|
|
$user = $this->createMock(IUser::class);
|
|
|
|
$token = 'goodToken';
|
|
|
|
$oldSessionId = 'sess321';
|
|
|
|
|
|
|
|
$session->expects($this->once())
|
|
|
|
->method('regenerateId');
|
2014-05-23 02:18:07 +04:00
|
|
|
$manager->expects($this->once())
|
|
|
|
->method('get')
|
|
|
|
->with('foo')
|
|
|
|
->will($this->returnValue($user));
|
2016-09-06 22:41:15 +03:00
|
|
|
$this->config->expects($this->once())
|
|
|
|
->method('getUserKeys')
|
|
|
|
->with('foo', 'login_token')
|
|
|
|
->will($this->returnValue(['anothertoken']));
|
|
|
|
$this->config->expects($this->never())
|
|
|
|
->method('deleteUserValue')
|
|
|
|
->with('foo', 'login_token', $token);
|
|
|
|
|
|
|
|
$this->tokenProvider->expects($this->never())
|
|
|
|
->method('renewSessionToken');
|
|
|
|
$userSession->expects($this->never())
|
|
|
|
->method('setMagicInCookie');
|
|
|
|
$user->expects($this->never())
|
|
|
|
->method('updateLastLoginTimestamp');
|
|
|
|
$session->expects($this->never())
|
|
|
|
->method('set')
|
|
|
|
->with('user_id', 'foo');
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
$granted = $userSession->loginWithCookie('foo', $token, $oldSessionId);
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
$this->assertFalse($granted);
|
2014-05-23 02:18:07 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
public function testRememberLoginInvalidUser() {
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->getMockBuilder(Memory::class)->setConstructorArgs([''])->getMock();
|
2016-09-06 22:41:15 +03:00
|
|
|
$managerMethods = get_class_methods(\OC\User\Manager::class);
|
|
|
|
//keep following methods intact in order to ensure hooks are working
|
|
|
|
$mockedManagerMethods = array_diff($managerMethods, ['__construct', 'emit', 'listen']);
|
2016-10-31 11:36:55 +03:00
|
|
|
$manager = $this->getMockBuilder(Manager::class)
|
|
|
|
->setMethods($mockedManagerMethods)
|
2019-02-22 15:07:26 +03:00
|
|
|
->setConstructorArgs([$this->config, $this->createMock(EventDispatcherInterface::class)])
|
2016-10-31 11:36:55 +03:00
|
|
|
->getMock();
|
2016-09-06 22:41:15 +03:00
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
|
|
|
//override, otherwise tests will fail because of setcookie()
|
|
|
|
->setMethods(['setMagicInCookie'])
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-09-06 22:41:15 +03:00
|
|
|
->getMock();
|
|
|
|
$token = 'goodToken';
|
|
|
|
$oldSessionId = 'sess321';
|
|
|
|
|
2016-01-04 17:00:58 +03:00
|
|
|
$session->expects($this->once())
|
2016-04-28 11:52:28 +03:00
|
|
|
->method('regenerateId');
|
2014-05-23 02:18:07 +04:00
|
|
|
$manager->expects($this->once())
|
|
|
|
->method('get')
|
|
|
|
->with('foo')
|
|
|
|
->will($this->returnValue(null));
|
2016-09-06 22:41:15 +03:00
|
|
|
$this->config->expects($this->never())
|
|
|
|
->method('getUserKeys')
|
|
|
|
->with('foo', 'login_token')
|
|
|
|
->will($this->returnValue(['anothertoken']));
|
|
|
|
|
|
|
|
$this->tokenProvider->expects($this->never())
|
|
|
|
->method('renewSessionToken');
|
|
|
|
$userSession->expects($this->never())
|
|
|
|
->method('setMagicInCookie');
|
|
|
|
$session->expects($this->never())
|
|
|
|
->method('set')
|
|
|
|
->with('user_id', 'foo');
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
$granted = $userSession->loginWithCookie('foo', $token, $oldSessionId);
|
2014-05-23 02:18:07 +04:00
|
|
|
|
2016-09-06 22:41:15 +03:00
|
|
|
$this->assertFalse($granted);
|
2014-05-23 02:18:07 +04:00
|
|
|
}
|
2014-10-13 18:31:26 +04:00
|
|
|
|
|
|
|
public function testActiveUserAfterSetSession() {
|
|
|
|
$users = array(
|
2019-02-22 15:07:26 +03:00
|
|
|
'foo' => new User('foo', null, $this->createMock(EventDispatcherInterface::class)),
|
|
|
|
'bar' => new User('bar', null, $this->createMock(EventDispatcherInterface::class))
|
2014-10-13 18:31:26 +04:00
|
|
|
);
|
|
|
|
|
|
|
|
$manager = $this->getMockBuilder('\OC\User\Manager')
|
|
|
|
->disableOriginalConstructor()
|
|
|
|
->getMock();
|
|
|
|
|
|
|
|
$manager->expects($this->any())
|
|
|
|
->method('get')
|
|
|
|
->will($this->returnCallback(function ($uid) use ($users) {
|
2016-10-10 14:59:55 +03:00
|
|
|
return $users[$uid];
|
|
|
|
}));
|
2014-10-13 18:31:26 +04:00
|
|
|
|
|
|
|
$session = new Memory('');
|
|
|
|
$session->set('user_id', 'foo');
|
2017-10-24 16:26:53 +03:00
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-04-28 11:52:28 +03:00
|
|
|
->setMethods([
|
|
|
|
'validateSession'
|
|
|
|
])
|
|
|
|
->getMock();
|
|
|
|
$userSession->expects($this->any())
|
|
|
|
->method('validateSession');
|
|
|
|
|
2014-10-13 18:31:26 +04:00
|
|
|
$this->assertEquals($users['foo'], $userSession->getUser());
|
|
|
|
|
|
|
|
$session2 = new Memory('');
|
|
|
|
$session2->set('user_id', 'bar');
|
|
|
|
$userSession->setSession($session2);
|
|
|
|
$this->assertEquals($users['bar'], $userSession->getUser());
|
|
|
|
}
|
2016-04-28 11:52:28 +03:00
|
|
|
|
2016-06-03 09:55:00 +03:00
|
|
|
public function testCreateSessionToken() {
|
2016-09-12 22:53:21 +03:00
|
|
|
$manager = $this->createMock(Manager::class);
|
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$user = $this->createMock(IUser::class);
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new \OC\User\Session($manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2016-06-03 09:55:00 +03:00
|
|
|
|
2016-09-12 22:53:21 +03:00
|
|
|
$random = $this->createMock(ISecureRandom::class);
|
|
|
|
$config = $this->createMock(IConfig::class);
|
2016-06-03 09:55:00 +03:00
|
|
|
$csrf = $this->getMockBuilder('\OC\Security\CSRF\CsrfTokenManager')
|
|
|
|
->disableOriginalConstructor()
|
|
|
|
->getMock();
|
|
|
|
$request = new \OC\AppFramework\Http\Request([
|
|
|
|
'server' => [
|
|
|
|
'HTTP_USER_AGENT' => 'Firefox',
|
|
|
|
]
|
|
|
|
], $random, $config, $csrf);
|
|
|
|
|
|
|
|
$uid = 'user123';
|
|
|
|
$loginName = 'User123';
|
|
|
|
$password = 'passme';
|
|
|
|
$sessionId = 'abcxyz';
|
|
|
|
|
|
|
|
$manager->expects($this->once())
|
|
|
|
->method('get')
|
|
|
|
->with($uid)
|
|
|
|
->will($this->returnValue($user));
|
|
|
|
$session->expects($this->once())
|
|
|
|
->method('getId')
|
|
|
|
->will($this->returnValue($sessionId));
|
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
|
|
|
->with($password)
|
|
|
|
->will($this->throwException(new \OC\Authentication\Exceptions\InvalidTokenException()));
|
2016-10-10 14:59:55 +03:00
|
|
|
|
2016-06-03 09:55:00 +03:00
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('generateToken')
|
2016-11-28 11:59:59 +03:00
|
|
|
->with($sessionId, $uid, $loginName, $password, 'Firefox', IToken::TEMPORARY_TOKEN, IToken::DO_NOT_REMEMBER);
|
2016-06-03 09:55:00 +03:00
|
|
|
|
|
|
|
$this->assertTrue($userSession->createSessionToken($request, $uid, $loginName, $password));
|
|
|
|
}
|
|
|
|
|
2016-11-27 15:59:46 +03:00
|
|
|
public function testCreateRememberedSessionToken() {
|
|
|
|
$manager = $this->createMock(Manager::class);
|
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$user = $this->createMock(IUser::class);
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new \OC\User\Session($manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2016-11-27 15:59:46 +03:00
|
|
|
|
|
|
|
$random = $this->createMock(ISecureRandom::class);
|
|
|
|
$config = $this->createMock(IConfig::class);
|
|
|
|
$csrf = $this->getMockBuilder('\OC\Security\CSRF\CsrfTokenManager')
|
|
|
|
->disableOriginalConstructor()
|
|
|
|
->getMock();
|
|
|
|
$request = new \OC\AppFramework\Http\Request([
|
|
|
|
'server' => [
|
|
|
|
'HTTP_USER_AGENT' => 'Firefox',
|
|
|
|
]
|
|
|
|
], $random, $config, $csrf);
|
|
|
|
|
|
|
|
$uid = 'user123';
|
|
|
|
$loginName = 'User123';
|
|
|
|
$password = 'passme';
|
|
|
|
$sessionId = 'abcxyz';
|
|
|
|
|
|
|
|
$manager->expects($this->once())
|
|
|
|
->method('get')
|
|
|
|
->with($uid)
|
|
|
|
->will($this->returnValue($user));
|
|
|
|
$session->expects($this->once())
|
|
|
|
->method('getId')
|
|
|
|
->will($this->returnValue($sessionId));
|
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
|
|
|
->with($password)
|
|
|
|
->will($this->throwException(new \OC\Authentication\Exceptions\InvalidTokenException()));
|
|
|
|
|
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('generateToken')
|
|
|
|
->with($sessionId, $uid, $loginName, $password, 'Firefox', IToken::TEMPORARY_TOKEN, IToken::REMEMBER);
|
|
|
|
|
|
|
|
$this->assertTrue($userSession->createSessionToken($request, $uid, $loginName, $password, true));
|
|
|
|
}
|
|
|
|
|
2016-06-03 09:55:00 +03:00
|
|
|
public function testCreateSessionTokenWithTokenPassword() {
|
|
|
|
$manager = $this->getMockBuilder('\OC\User\Manager')
|
|
|
|
->disableOriginalConstructor()
|
|
|
|
->getMock();
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$token = $this->createMock(IToken::class);
|
|
|
|
$user = $this->createMock(IUser::class);
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new \OC\User\Session($manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2016-06-03 09:55:00 +03:00
|
|
|
|
2016-09-12 22:53:21 +03:00
|
|
|
$random = $this->createMock(ISecureRandom::class);
|
|
|
|
$config = $this->createMock(IConfig::class);
|
2016-06-03 09:55:00 +03:00
|
|
|
$csrf = $this->getMockBuilder('\OC\Security\CSRF\CsrfTokenManager')
|
|
|
|
->disableOriginalConstructor()
|
|
|
|
->getMock();
|
|
|
|
$request = new \OC\AppFramework\Http\Request([
|
|
|
|
'server' => [
|
|
|
|
'HTTP_USER_AGENT' => 'Firefox',
|
|
|
|
]
|
|
|
|
], $random, $config, $csrf);
|
|
|
|
|
|
|
|
$uid = 'user123';
|
|
|
|
$loginName = 'User123';
|
|
|
|
$password = 'iamatoken';
|
|
|
|
$realPassword = 'passme';
|
|
|
|
$sessionId = 'abcxyz';
|
|
|
|
|
|
|
|
$manager->expects($this->once())
|
|
|
|
->method('get')
|
|
|
|
->with($uid)
|
|
|
|
->will($this->returnValue($user));
|
|
|
|
$session->expects($this->once())
|
|
|
|
->method('getId')
|
|
|
|
->will($this->returnValue($sessionId));
|
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
|
|
|
->with($password)
|
|
|
|
->will($this->returnValue($token));
|
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('getPassword')
|
|
|
|
->with($token, $password)
|
|
|
|
->will($this->returnValue($realPassword));
|
2016-10-10 14:59:55 +03:00
|
|
|
|
2016-06-03 09:55:00 +03:00
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('generateToken')
|
2016-11-27 15:59:46 +03:00
|
|
|
->with($sessionId, $uid, $loginName, $realPassword, 'Firefox', IToken::TEMPORARY_TOKEN, IToken::DO_NOT_REMEMBER);
|
2016-06-03 09:55:00 +03:00
|
|
|
|
|
|
|
$this->assertTrue($userSession->createSessionToken($request, $uid, $loginName, $password));
|
|
|
|
}
|
|
|
|
|
|
|
|
public function testCreateSessionTokenWithNonExistentUser() {
|
|
|
|
$manager = $this->getMockBuilder('\OC\User\Manager')
|
|
|
|
->disableOriginalConstructor()
|
|
|
|
->getMock();
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->createMock(ISession::class);
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new \OC\User\Session($manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2016-09-12 22:53:21 +03:00
|
|
|
$request = $this->createMock(IRequest::class);
|
2016-06-03 09:55:00 +03:00
|
|
|
|
|
|
|
$uid = 'user123';
|
|
|
|
$loginName = 'User123';
|
|
|
|
$password = 'passme';
|
|
|
|
|
|
|
|
$manager->expects($this->once())
|
|
|
|
->method('get')
|
|
|
|
->with($uid)
|
|
|
|
->will($this->returnValue(null));
|
2016-10-10 14:59:55 +03:00
|
|
|
|
2016-06-03 09:55:00 +03:00
|
|
|
$this->assertFalse($userSession->createSessionToken($request, $uid, $loginName, $password));
|
|
|
|
}
|
|
|
|
|
2016-06-27 23:16:22 +03:00
|
|
|
/**
|
|
|
|
* @expectedException \OC\User\LoginException
|
|
|
|
*/
|
2016-05-17 11:32:47 +03:00
|
|
|
public function testTryTokenLoginWithDisabledUser() {
|
|
|
|
$manager = $this->getMockBuilder('\OC\User\Manager')
|
|
|
|
->disableOriginalConstructor()
|
|
|
|
->getMock();
|
|
|
|
$session = new Memory('');
|
2016-06-20 11:41:23 +03:00
|
|
|
$token = new \OC\Authentication\Token\DefaultToken();
|
|
|
|
$token->setLoginName('fritz');
|
|
|
|
$token->setUid('fritz0');
|
|
|
|
$token->setLastCheck(100); // Needs check
|
2016-09-12 22:53:21 +03:00
|
|
|
$user = $this->createMock(IUser::class);
|
2017-10-24 16:26:53 +03:00
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
2016-06-20 11:41:23 +03:00
|
|
|
->setMethods(['logout'])
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$manager, $session, $this->timeFactory, $this->tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-06-20 11:41:23 +03:00
|
|
|
->getMock();
|
2016-09-12 22:53:21 +03:00
|
|
|
$request = $this->createMock(IRequest::class);
|
2016-05-17 11:32:47 +03:00
|
|
|
|
|
|
|
$request->expects($this->once())
|
|
|
|
->method('getHeader')
|
|
|
|
->with('Authorization')
|
2017-05-18 21:36:02 +03:00
|
|
|
->will($this->returnValue('Bearer xxxxx'));
|
2016-06-03 09:55:00 +03:00
|
|
|
$this->tokenProvider->expects($this->once())
|
2016-06-20 11:41:23 +03:00
|
|
|
->method('getToken')
|
2016-05-17 11:32:47 +03:00
|
|
|
->with('xxxxx')
|
|
|
|
->will($this->returnValue($token));
|
|
|
|
$manager->expects($this->once())
|
|
|
|
->method('get')
|
2016-06-20 11:41:23 +03:00
|
|
|
->with('fritz0')
|
2016-05-17 11:32:47 +03:00
|
|
|
->will($this->returnValue($user));
|
|
|
|
$user->expects($this->once())
|
|
|
|
->method('isEnabled')
|
|
|
|
->will($this->returnValue(false));
|
|
|
|
|
2016-06-27 23:16:22 +03:00
|
|
|
$userSession->tryTokenLogin($request);
|
2016-05-17 11:32:47 +03:00
|
|
|
}
|
|
|
|
|
2016-05-17 11:07:58 +03:00
|
|
|
public function testValidateSessionDisabledUser() {
|
2018-01-23 11:58:46 +03:00
|
|
|
$userManager = $this->createMock(Manager::class);
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$timeFactory = $this->createMock(ITimeFactory::class);
|
|
|
|
$tokenProvider = $this->createMock(IProvider::class);
|
2017-10-24 16:26:53 +03:00
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$userManager, $session, $timeFactory, $tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-05-17 11:07:58 +03:00
|
|
|
->setMethods(['logout'])
|
|
|
|
->getMock();
|
|
|
|
|
2016-09-12 22:53:21 +03:00
|
|
|
$user = $this->createMock(IUser::class);
|
2016-06-20 10:10:11 +03:00
|
|
|
$token = new \OC\Authentication\Token\DefaultToken();
|
|
|
|
$token->setLoginName('susan');
|
|
|
|
$token->setLastCheck(20);
|
2016-05-17 11:07:58 +03:00
|
|
|
|
|
|
|
$session->expects($this->once())
|
2016-06-20 10:10:11 +03:00
|
|
|
->method('get')
|
|
|
|
->with('app_password')
|
|
|
|
->will($this->returnValue('APP-PASSWORD'));
|
2016-05-17 11:07:58 +03:00
|
|
|
$tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
2016-06-20 10:10:11 +03:00
|
|
|
->with('APP-PASSWORD')
|
2016-05-17 11:07:58 +03:00
|
|
|
->will($this->returnValue($token));
|
|
|
|
$timeFactory->expects($this->once())
|
|
|
|
->method('getTime')
|
2016-06-20 10:10:11 +03:00
|
|
|
->will($this->returnValue(1000)); // more than 5min since last check
|
2016-05-17 11:07:58 +03:00
|
|
|
$tokenProvider->expects($this->once())
|
|
|
|
->method('getPassword')
|
2016-06-20 10:10:11 +03:00
|
|
|
->with($token, 'APP-PASSWORD')
|
2016-05-17 11:07:58 +03:00
|
|
|
->will($this->returnValue('123456'));
|
2018-09-26 14:10:17 +03:00
|
|
|
$userManager->expects($this->never())
|
|
|
|
->method('checkPassword');
|
2016-05-17 11:07:58 +03:00
|
|
|
$user->expects($this->once())
|
|
|
|
->method('isEnabled')
|
|
|
|
->will($this->returnValue(false));
|
2016-06-20 11:41:23 +03:00
|
|
|
$tokenProvider->expects($this->once())
|
2016-06-20 10:10:11 +03:00
|
|
|
->method('invalidateToken')
|
2016-06-20 11:41:23 +03:00
|
|
|
->with('APP-PASSWORD');
|
2016-05-17 11:07:58 +03:00
|
|
|
$userSession->expects($this->once())
|
|
|
|
->method('logout');
|
|
|
|
|
2016-06-20 11:41:23 +03:00
|
|
|
$userSession->setUser($user);
|
|
|
|
$this->invokePrivate($userSession, 'validateSession');
|
2016-05-17 11:07:58 +03:00
|
|
|
}
|
|
|
|
|
2016-05-31 11:48:14 +03:00
|
|
|
public function testValidateSessionNoPassword() {
|
2018-01-23 11:58:46 +03:00
|
|
|
$userManager = $this->createMock(Manager::class);
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$timeFactory = $this->createMock(ITimeFactory::class);
|
|
|
|
$tokenProvider = $this->createMock(IProvider::class);
|
2017-10-24 16:26:53 +03:00
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$userManager, $session, $timeFactory, $tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2016-05-31 11:48:14 +03:00
|
|
|
->setMethods(['logout'])
|
|
|
|
->getMock();
|
|
|
|
|
2016-09-12 22:53:21 +03:00
|
|
|
$user = $this->createMock(IUser::class);
|
2016-06-20 10:10:11 +03:00
|
|
|
$token = new \OC\Authentication\Token\DefaultToken();
|
|
|
|
$token->setLastCheck(20);
|
2016-05-31 11:48:14 +03:00
|
|
|
|
|
|
|
$session->expects($this->once())
|
2016-06-20 10:10:11 +03:00
|
|
|
->method('get')
|
|
|
|
->with('app_password')
|
|
|
|
->will($this->returnValue('APP-PASSWORD'));
|
2016-05-31 11:48:14 +03:00
|
|
|
$tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
2016-06-20 10:10:11 +03:00
|
|
|
->with('APP-PASSWORD')
|
2016-05-31 11:48:14 +03:00
|
|
|
->will($this->returnValue($token));
|
|
|
|
$timeFactory->expects($this->once())
|
|
|
|
->method('getTime')
|
2016-06-20 10:10:11 +03:00
|
|
|
->will($this->returnValue(1000)); // more than 5min since last check
|
2016-05-31 11:48:14 +03:00
|
|
|
$tokenProvider->expects($this->once())
|
|
|
|
->method('getPassword')
|
2016-06-20 10:10:11 +03:00
|
|
|
->with($token, 'APP-PASSWORD')
|
2016-05-31 11:48:14 +03:00
|
|
|
->will($this->throwException(new \OC\Authentication\Exceptions\PasswordlessTokenException()));
|
|
|
|
|
|
|
|
$this->invokePrivate($userSession, 'validateSession', [$user]);
|
2016-06-20 10:10:11 +03:00
|
|
|
|
|
|
|
$this->assertEquals(1000, $token->getLastCheck());
|
2016-05-31 11:48:14 +03:00
|
|
|
}
|
|
|
|
|
2018-10-02 12:50:41 +03:00
|
|
|
public function testValidateSessionInvalidPassword() {
|
|
|
|
$userManager = $this->createMock(Manager::class);
|
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$timeFactory = $this->createMock(ITimeFactory::class);
|
|
|
|
$tokenProvider = $this->createMock(IProvider::class);
|
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
2019-07-28 21:46:01 +03:00
|
|
|
->setConstructorArgs([$userManager, $session, $timeFactory, $tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher])
|
2018-10-02 12:50:41 +03:00
|
|
|
->setMethods(['logout'])
|
|
|
|
->getMock();
|
|
|
|
|
|
|
|
$user = $this->createMock(IUser::class);
|
|
|
|
$token = new \OC\Authentication\Token\DefaultToken();
|
|
|
|
$token->setLoginName('susan');
|
|
|
|
$token->setLastCheck(20);
|
|
|
|
|
|
|
|
$session->expects($this->once())
|
|
|
|
->method('get')
|
|
|
|
->with('app_password')
|
|
|
|
->will($this->returnValue('APP-PASSWORD'));
|
|
|
|
$tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
|
|
|
->with('APP-PASSWORD')
|
|
|
|
->will($this->returnValue($token));
|
|
|
|
$timeFactory->expects($this->once())
|
|
|
|
->method('getTime')
|
|
|
|
->will($this->returnValue(1000)); // more than 5min since last check
|
|
|
|
$tokenProvider->expects($this->once())
|
|
|
|
->method('getPassword')
|
|
|
|
->with($token, 'APP-PASSWORD')
|
|
|
|
->will($this->returnValue('123456'));
|
|
|
|
$userManager->expects($this->once())
|
|
|
|
->method('checkPassword')
|
|
|
|
->with('susan', '123456')
|
|
|
|
->willReturn(false);
|
|
|
|
$user->expects($this->once())
|
|
|
|
->method('isEnabled')
|
|
|
|
->will($this->returnValue(true));
|
|
|
|
$tokenProvider->expects($this->never())
|
|
|
|
->method('invalidateToken');
|
|
|
|
$tokenProvider->expects($this->once())
|
|
|
|
->method('markPasswordInvalid')
|
|
|
|
->with($token, 'APP-PASSWORD');
|
|
|
|
$userSession->expects($this->once())
|
|
|
|
->method('logout');
|
|
|
|
|
|
|
|
$userSession->setUser($user);
|
|
|
|
$this->invokePrivate($userSession, 'validateSession');
|
|
|
|
}
|
|
|
|
|
2016-06-21 11:23:50 +03:00
|
|
|
public function testUpdateSessionTokenPassword() {
|
2018-01-23 11:58:46 +03:00
|
|
|
$userManager = $this->createMock(Manager::class);
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$timeFactory = $this->createMock(ITimeFactory::class);
|
|
|
|
$tokenProvider = $this->createMock(IProvider::class);
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new \OC\User\Session($userManager, $session, $timeFactory, $tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2016-06-21 11:23:50 +03:00
|
|
|
|
|
|
|
$password = '123456';
|
2016-10-10 14:59:55 +03:00
|
|
|
$sessionId = 'session1234';
|
2016-06-21 11:23:50 +03:00
|
|
|
$token = new \OC\Authentication\Token\DefaultToken();
|
|
|
|
|
|
|
|
$session->expects($this->once())
|
|
|
|
->method('getId')
|
|
|
|
->will($this->returnValue($sessionId));
|
|
|
|
$tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
|
|
|
->with($sessionId)
|
|
|
|
->will($this->returnValue($token));
|
|
|
|
$tokenProvider->expects($this->once())
|
|
|
|
->method('setPassword')
|
|
|
|
->with($token, $sessionId, $password);
|
|
|
|
|
|
|
|
$userSession->updateSessionTokenPassword($password);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function testUpdateSessionTokenPasswordNoSessionAvailable() {
|
2018-01-23 11:58:46 +03:00
|
|
|
$userManager = $this->createMock(Manager::class);
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$timeFactory = $this->createMock(ITimeFactory::class);
|
|
|
|
$tokenProvider = $this->createMock(IProvider::class);
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new \OC\User\Session($userManager, $session, $timeFactory, $tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2016-06-21 11:23:50 +03:00
|
|
|
|
|
|
|
$session->expects($this->once())
|
|
|
|
->method('getId')
|
|
|
|
->will($this->throwException(new \OCP\Session\Exceptions\SessionNotAvailableException()));
|
|
|
|
|
|
|
|
$userSession->updateSessionTokenPassword('1234');
|
|
|
|
}
|
|
|
|
|
|
|
|
public function testUpdateSessionTokenPasswordInvalidTokenException() {
|
2018-01-23 11:58:46 +03:00
|
|
|
$userManager = $this->createMock(Manager::class);
|
2016-09-12 22:53:21 +03:00
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$timeFactory = $this->createMock(ITimeFactory::class);
|
|
|
|
$tokenProvider = $this->createMock(IProvider::class);
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new \OC\User\Session($userManager, $session, $timeFactory, $tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2016-06-21 11:23:50 +03:00
|
|
|
|
|
|
|
$password = '123456';
|
2016-10-10 14:59:55 +03:00
|
|
|
$sessionId = 'session1234';
|
2016-06-21 11:23:50 +03:00
|
|
|
$token = new \OC\Authentication\Token\DefaultToken();
|
|
|
|
|
|
|
|
$session->expects($this->once())
|
|
|
|
->method('getId')
|
|
|
|
->will($this->returnValue($sessionId));
|
|
|
|
$tokenProvider->expects($this->once())
|
|
|
|
->method('getToken')
|
|
|
|
->with($sessionId)
|
|
|
|
->will($this->returnValue($token));
|
|
|
|
$tokenProvider->expects($this->once())
|
|
|
|
->method('setPassword')
|
|
|
|
->with($token, $sessionId, $password)
|
|
|
|
->will($this->throwException(new \OC\Authentication\Exceptions\InvalidTokenException()));
|
|
|
|
|
|
|
|
$userSession->updateSessionTokenPassword($password);
|
|
|
|
}
|
|
|
|
|
2016-10-10 14:59:55 +03:00
|
|
|
public function testUpdateAuthTokenLastCheck() {
|
2016-10-25 10:34:11 +03:00
|
|
|
$manager = $this->createMock(Manager::class);
|
2016-10-10 14:59:55 +03:00
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$request = $this->createMock(IRequest::class);
|
|
|
|
|
|
|
|
$token = new \OC\Authentication\Token\DefaultToken();
|
|
|
|
$token->setUid('john');
|
|
|
|
$token->setLoginName('john');
|
|
|
|
$token->setLastActivity(100);
|
|
|
|
$token->setLastCheck(100);
|
|
|
|
|
|
|
|
$mapper = $this->getMockBuilder(DefaultTokenMapper::class)
|
|
|
|
->disableOriginalConstructor()
|
|
|
|
->getMock();
|
2016-10-25 10:34:11 +03:00
|
|
|
$crypto = $this->createMock(ICrypto::class);
|
|
|
|
$logger = $this->createMock(ILogger::class);
|
2016-10-10 14:59:55 +03:00
|
|
|
$tokenProvider = new DefaultTokenProvider($mapper, $crypto, $this->config, $logger, $this->timeFactory);
|
|
|
|
|
|
|
|
/** @var \OC\User\Session $userSession */
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new Session($manager, $session, $this->timeFactory, $tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2016-10-10 14:59:55 +03:00
|
|
|
|
|
|
|
$mapper->expects($this->any())
|
|
|
|
->method('getToken')
|
|
|
|
->will($this->returnValue($token));
|
|
|
|
$mapper->expects($this->once())
|
|
|
|
->method('update');
|
|
|
|
$request
|
|
|
|
->expects($this->any())
|
|
|
|
->method('getRemoteAddress')
|
|
|
|
->willReturn('192.168.0.1');
|
|
|
|
$this->throttler
|
|
|
|
->expects($this->once())
|
|
|
|
->method('sleepDelay')
|
|
|
|
->with('192.168.0.1');
|
|
|
|
$this->throttler
|
|
|
|
->expects($this->any())
|
|
|
|
->method('getDelay')
|
|
|
|
->with('192.168.0.1')
|
|
|
|
->willReturn(0);
|
|
|
|
$this->timeFactory
|
|
|
|
->expects($this->any())
|
|
|
|
->method('getTime')
|
|
|
|
->will($this->returnValue(100));
|
|
|
|
|
2017-08-09 17:13:54 +03:00
|
|
|
$manager->method('getByEmail')
|
|
|
|
->with('john')
|
|
|
|
->willReturn([]);
|
|
|
|
|
2016-10-10 14:59:55 +03:00
|
|
|
$userSession->logClientIn('john', 'doe', $request, $this->throttler);
|
|
|
|
|
|
|
|
$this->assertEquals(10000, $token->getLastActivity());
|
|
|
|
$this->assertEquals(10000, $token->getLastCheck());
|
|
|
|
}
|
|
|
|
|
|
|
|
public function testNoUpdateAuthTokenLastCheckRecent() {
|
2016-10-25 10:34:11 +03:00
|
|
|
$manager = $this->createMock(Manager::class);
|
2016-10-10 14:59:55 +03:00
|
|
|
$session = $this->createMock(ISession::class);
|
|
|
|
$request = $this->createMock(IRequest::class);
|
|
|
|
|
|
|
|
$token = new \OC\Authentication\Token\DefaultToken();
|
|
|
|
$token->setUid('john');
|
|
|
|
$token->setLoginName('john');
|
|
|
|
$token->setLastActivity(10000);
|
|
|
|
$token->setLastCheck(100);
|
|
|
|
|
|
|
|
$mapper = $this->getMockBuilder(DefaultTokenMapper::class)
|
|
|
|
->disableOriginalConstructor()
|
|
|
|
->getMock();
|
2016-10-25 10:34:11 +03:00
|
|
|
$crypto = $this->createMock(ICrypto::class);
|
|
|
|
$logger = $this->createMock(ILogger::class);
|
2016-10-10 14:59:55 +03:00
|
|
|
$tokenProvider = new DefaultTokenProvider($mapper, $crypto, $this->config, $logger, $this->timeFactory);
|
|
|
|
|
|
|
|
/** @var \OC\User\Session $userSession */
|
2019-07-28 21:46:01 +03:00
|
|
|
$userSession = new Session($manager, $session, $this->timeFactory, $tokenProvider, $this->config, $this->random, $this->lockdownManager, $this->logger, $this->dispatcher);
|
2016-10-10 14:59:55 +03:00
|
|
|
|
|
|
|
$mapper->expects($this->any())
|
|
|
|
->method('getToken')
|
|
|
|
->will($this->returnValue($token));
|
|
|
|
$mapper->expects($this->never())
|
|
|
|
->method('update');
|
|
|
|
$request
|
|
|
|
->expects($this->any())
|
|
|
|
->method('getRemoteAddress')
|
|
|
|
->willReturn('192.168.0.1');
|
|
|
|
$this->throttler
|
|
|
|
->expects($this->once())
|
|
|
|
->method('sleepDelay')
|
|
|
|
->with('192.168.0.1');
|
|
|
|
$this->throttler
|
|
|
|
->expects($this->any())
|
|
|
|
->method('getDelay')
|
|
|
|
->with('192.168.0.1')
|
|
|
|
->willReturn(0);
|
|
|
|
$this->timeFactory
|
|
|
|
->expects($this->any())
|
|
|
|
->method('getTime')
|
|
|
|
->will($this->returnValue(100));
|
|
|
|
|
2017-08-09 17:13:54 +03:00
|
|
|
$manager->method('getByEmail')
|
|
|
|
->with('john')
|
|
|
|
->willReturn([]);
|
|
|
|
|
2016-10-10 14:59:55 +03:00
|
|
|
$userSession->logClientIn('john', 'doe', $request, $this->throttler);
|
|
|
|
}
|
2016-11-02 15:37:39 +03:00
|
|
|
|
|
|
|
public function testCreateRememberMeToken() {
|
|
|
|
$user = $this->createMock(IUser::class);
|
|
|
|
$user
|
|
|
|
->expects($this->exactly(2))
|
|
|
|
->method('getUID')
|
|
|
|
->willReturn('UserUid');
|
|
|
|
$this->random
|
|
|
|
->expects($this->once())
|
|
|
|
->method('generate')
|
|
|
|
->with(32)
|
|
|
|
->willReturn('LongRandomToken');
|
|
|
|
$this->config
|
|
|
|
->expects($this->once())
|
|
|
|
->method('setUserValue')
|
|
|
|
->with('UserUid', 'login_token', 'LongRandomToken', 10000);
|
|
|
|
$this->userSession
|
|
|
|
->expects($this->once())
|
|
|
|
->method('setMagicInCookie')
|
|
|
|
->with('UserUid', 'LongRandomToken');
|
|
|
|
|
|
|
|
$this->userSession->createRememberMeToken($user);
|
|
|
|
}
|
2016-12-05 22:57:15 +03:00
|
|
|
|
|
|
|
public function testTryBasicAuthLoginValid() {
|
|
|
|
$request = $this->createMock(Request::class);
|
|
|
|
$request->method('__get')
|
|
|
|
->willReturn([
|
|
|
|
'PHP_AUTH_USER' => 'username',
|
|
|
|
'PHP_AUTH_PW' => 'password',
|
|
|
|
]);
|
|
|
|
$request->method('__isset')
|
|
|
|
->with('server')
|
|
|
|
->willReturn(true);
|
|
|
|
|
|
|
|
$davAuthenticatedSet = false;
|
|
|
|
$lastPasswordConfirmSet = false;
|
|
|
|
|
|
|
|
$this->session
|
|
|
|
->method('set')
|
|
|
|
->will($this->returnCallback(function($k, $v) use (&$davAuthenticatedSet, &$lastPasswordConfirmSet) {
|
|
|
|
switch ($k) {
|
|
|
|
case Auth::DAV_AUTHENTICATED:
|
|
|
|
$davAuthenticatedSet = $v;
|
|
|
|
return;
|
|
|
|
case 'last-password-confirm':
|
|
|
|
$lastPasswordConfirmSet = 1000;
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
throw new \Exception();
|
|
|
|
}
|
|
|
|
}));
|
|
|
|
|
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
|
|
|
->setConstructorArgs([
|
|
|
|
$this->manager,
|
|
|
|
$this->session,
|
|
|
|
$this->timeFactory,
|
|
|
|
$this->tokenProvider,
|
|
|
|
$this->config,
|
|
|
|
$this->random,
|
2018-01-23 11:58:46 +03:00
|
|
|
$this->lockdownManager,
|
2019-07-28 21:46:01 +03:00
|
|
|
$this->logger,
|
|
|
|
$this->dispatcher
|
2016-12-05 22:57:15 +03:00
|
|
|
])
|
|
|
|
->setMethods([
|
|
|
|
'logClientIn',
|
|
|
|
'getUser',
|
|
|
|
])
|
|
|
|
->getMock();
|
|
|
|
|
2019-07-28 21:46:01 +03:00
|
|
|
/** @var Session|MockObject */
|
2016-12-05 22:57:15 +03:00
|
|
|
$userSession->expects($this->once())
|
|
|
|
->method('logClientIn')
|
|
|
|
->with(
|
|
|
|
$this->equalTo('username'),
|
|
|
|
$this->equalTo('password'),
|
|
|
|
$this->equalTo($request),
|
|
|
|
$this->equalTo($this->throttler)
|
|
|
|
)->willReturn(true);
|
|
|
|
|
|
|
|
$user = $this->createMock(IUser::class);
|
|
|
|
$user->method('getUID')->willReturn('username');
|
|
|
|
|
|
|
|
$userSession->expects($this->once())
|
|
|
|
->method('getUser')
|
|
|
|
->willReturn($user);
|
|
|
|
|
|
|
|
$this->assertTrue($userSession->tryBasicAuthLogin($request, $this->throttler));
|
|
|
|
|
|
|
|
$this->assertSame('username', $davAuthenticatedSet);
|
|
|
|
$this->assertSame(1000, $lastPasswordConfirmSet);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function testTryBasicAuthLoginNoLogin() {
|
|
|
|
$request = $this->createMock(Request::class);
|
|
|
|
$request->method('__get')
|
|
|
|
->willReturn([]);
|
|
|
|
$request->method('__isset')
|
|
|
|
->with('server')
|
|
|
|
->willReturn(true);
|
|
|
|
|
|
|
|
$this->session->expects($this->never())
|
|
|
|
->method($this->anything());
|
|
|
|
|
|
|
|
$userSession = $this->getMockBuilder(Session::class)
|
|
|
|
->setConstructorArgs([
|
|
|
|
$this->manager,
|
|
|
|
$this->session,
|
|
|
|
$this->timeFactory,
|
|
|
|
$this->tokenProvider,
|
|
|
|
$this->config,
|
|
|
|
$this->random,
|
2018-01-23 11:58:46 +03:00
|
|
|
$this->lockdownManager,
|
2019-07-28 21:46:01 +03:00
|
|
|
$this->logger,
|
|
|
|
$this->dispatcher
|
2016-12-05 22:57:15 +03:00
|
|
|
])
|
|
|
|
->setMethods([
|
|
|
|
'logClientIn',
|
|
|
|
])
|
|
|
|
->getMock();
|
|
|
|
|
2019-07-28 21:46:01 +03:00
|
|
|
/** @var Session|MockObject */
|
2016-12-05 22:57:15 +03:00
|
|
|
$userSession->expects($this->never())
|
|
|
|
->method('logClientIn');
|
|
|
|
|
|
|
|
$this->assertFalse($userSession->tryBasicAuthLogin($request, $this->throttler));
|
|
|
|
}
|
2018-10-02 12:50:41 +03:00
|
|
|
|
|
|
|
public function testUpdateTokens() {
|
|
|
|
$this->tokenProvider->expects($this->once())
|
|
|
|
->method('updatePasswords')
|
|
|
|
->with('uid', 'pass');
|
|
|
|
|
|
|
|
$this->userSession->updateTokens('uid', 'pass');
|
|
|
|
}
|
2013-05-29 01:46:57 +04:00
|
|
|
}
|