/**
*
* @ORM\PrePersist
*/
public function generateSecurekey()
{
$generator = new SecureRandom();
$random = $generator->nextBytes(150);
$securekey = md5($random . time());
$this->setSecurekey($securekey);
}
public function loadUserByOAuthUserResponse(UserResponseInterface $response)
{
$generator = new SecureRandom();
$random = $generator->nextBytes(10);
$data = $response->getResponse();
$username = $response->getUsername();
$email = $response->getEmail() ? $response->getEmail() : $username;
$service = $response->getResourceOwner()->getName();
$user = $this->userManager->findUserBy(array($this->getProperty($response) => $username));
//$user = $this->userManager->findUserBy(array($service.'Id' => $username));
//when the user is registrating
if (null === $user) {
$setter = 'set' . ucfirst($service);
$setter_id = $setter . 'Id';
$setter_token = $setter . 'AccessToken';
// create new user here
$user = $this->userManager->createUser();
$user->{$setter_id}($username);
$user->{$setter_token}($response->getAccessToken());
$user->setUsername($email);
$user->setEmail($email);
$user->setPlainPassword($random);
$user->setName($response->getRealName());
$user->setEnabled(true);
$this->userManager->updateUser($user);
return $user;
}
//if user exists - go with the HWIOAuth way
$user = parent::loadUserByOAuthUserResponse($response);
$serviceName = $response->getResourceOwner()->getName();
$setter = 'set' . ucfirst($serviceName) . 'AccessToken';
//update access token
$user->{$setter}($response->getAccessToken());
return $user;
}
/**
* @Route("/api/vote/{id}", name="vote")
*/
public function voteAction(Request $request, $id)
{
$isAjax = $request->isXmlHttpRequest();
if (!$isAjax) {
return $this->redirectToRoute('homepage');
}
try {
$em = $this->getDoctrine()->getManager();
$suggestion = $em->getRepository('AppBundle:Suggestion')->findOneById($id);
if (!$suggestion) {
return new JsonResponse(array('error' => 'Tento podnet neexistuje.'), 404);
}
$vote = new Vote();
$vote->setIp($request->getClientIp());
$vote->setFingerprint($request->get('fingerprint'));
$vote->setSuggestion($suggestion);
$cookie = $request->cookies->get('vote-' . $id);
if (!$cookie) {
$generator = new SecureRandom();
$random = $generator->nextBytes(10);
$cookie = new Cookie('vote-' . $id, $random);
$vote->setCookie($cookie);
} else {
return new JsonResponse(array('error' => 'Za tento podnet ste už hlasoval.'), 409);
}
$em->persist($vote);
$em->flush();
$response = new JsonResponse(array('msg' => 'ok'));
$response->headers->setCookie($cookie);
return $response;
} catch (UniqueConstraintViolationException $e) {
return new JsonResponse(array('error' => 'Za tento podnet ste už hlasoval.'), 409);
}
}
/**
* @Route("/inscription", name="register")
*/
public function registerAction(Request $request)
{
$user = new User();
$registerForm = $this->createForm(new RegisterType(), $user);
$registerForm->handleRequest($request);
if ($registerForm->isValid()) {
$user->setDateRegistered(new \DateTime());
$user->setDateModified(new \DateTime());
$user->setRoles(array("ROLE_ADMIN"));
$generator = new SecureRandom();
$salt = bin2hex($generator->nextBytes(30));
$token = bin2hex($generator->nextBytes(30));
$user->setSalt($salt);
$user->setToken($token);
$encoder = $this->get('security.password_encoder');
$encoded = $encoder->encodePassword($user, $user->getPlainPassword());
$user->setPassword($encoded);
dump($user);
$em = $this->getDoctrine()->getManager();
$em->persist($user);
$em->flush();
}
$params = ['registerForm' => $registerForm->createView()];
return $this->render('user/register.html.twig', $params);
}
public function profIndexAction(Request $request)
{
$professor = $this->getUser();
$course = new Course();
$course->setProfessor($professor);
$form = $this->createForm(new CourseType($professor), $course);
$form->handleRequest($request);
if ($form->isValid()) {
$generator = new SecureRandom();
$random = $generator->nextBytes(10);
$random = bin2hex($random);
$course->setHash($random);
$em = $this->getDoctrine()->getManager();
$em->persist($course);
$em->flush();
// Send email
$mailer = $this->get('mathsup.course.mailer');
$mailer->sendCourseNotificationMail($course);
$request->getSession()->getFlashBag()->add('success', 'course.flash.created');
$url = $this->generateUrl('mathsup_course');
return $this->redirect($url);
}
$courseRepo = $this->getDoctrine()->getRepository('MathsupCouponBundle:Course');
return $this->render('MathsupCouponBundle:Course:index.html.twig', array('new_form' => $form->createView(), 'last_not_validated_courses' => $courseRepo->findProfessorLastNotValidatedCourses($professor), 'last_courses' => $courseRepo->findProfessorLastValidatedCourses($professor)));
}
public function create($url, $code = null)
{
$repository = $this->doctrine->getRepository('AppBundle:ShortUrl');
// Check if URL Hash doesn't already exists
$hash = sha1($url);
$shortUrl = $repository->findOneByHash($hash);
if ($shortUrl) {
return $shortUrl;
}
// Check if Code doesn't exists, if so don't use that code
$shortUrl = $repository->findOneByCode($code);
if ($shortUrl) {
$code = null;
}
// Generate Code
if ($code == null) {
$generator = new SecureRandom();
$random = base64_encode($generator->nextBytes(64));
$random = preg_replace('/[^\\da-z]/i', '', $random);
$positions = floor(strlen($random) / 6);
$code = '';
for ($i = 0; $i < 6; $i++) {
$code .= substr($random, $i * $positions, 1);
}
}
// Generate Short URL
$shortUrl = new ShortUrl();
$shortUrl->setUrl($url)->setHash($hash)->setCode($code)->setClicks(0);
$this->doctrine->getManager()->persist($shortUrl);
$this->doctrine->getManager()->flush();
return $shortUrl;
}
/**
* @param int $userId
*
* @return string
*/
public function createUserToken($userId)
{
$generator = new SecureRandom();
$rand = $generator->nextBytes(12);
$wsseToken = sha1($rand);
$this->redis->setex(self::PREFIX . ':' . $userId, $this->ttl, $wsseToken);
return $wsseToken;
}
/**
* Resets the users password, and returns the unhashed password
* @param User $user
* @return string
*/
public function resetPassword(User $user)
{
$securityRandom = new SecureRandom();
$password = $securityRandom->nextBytes(8);
$user->setPassword($password);
$this->hashUserPassword($user);
return $password;
}
/**
* @Route("/redirect_sso", name="redirect_sso")
*/
public function redirectAction()
{
$gen = new SecureRandom();
$nonce = md5($gen->nextBytes(10));
$session = $this->get('session');
$session->set('eve_sso_nonce', $nonce);
return $this->redirect(join('', [self::AUTH_URI, '?', http_build_query(['response_type' => 'code', 'redirect_uri' => $this->generateUrl('sso_callback', [], true), 'scope' => '', 'client_id' => $this->container->getParameter('eve_client_id'), 'state' => $nonce])]));
}
public function getSessionState($client_id, $sessionId)
{
$generator = new SecureRandom();
$client = $this->getClient($client_id);
$url = $client->getMetadata()->getClientUri();
$salt = bin2hex($generator->nextBytes(15));
$state = $client_id . $url . $sessionId . $salt;
return hash('sha256', $state) . ".{$salt}";
}
/**
* @param User $user
* @param \DateTime null $expireAt
*/
public function __construct(User $user, \DateTime $expireAt = null)
{
$request = Request::createFromGlobals();
$random = new SecureRandom();
$this->user = $user;
$this->token = md5($random->nextBytes(24));
$this->userAgent = $request->headers->get('User-Agent');
$this->ipAddress = $request->getClientIp();
$this->expireAt = $expireAt ?: new \DateTime('+1 year');
}
private function creatGroup($username, $password, $officialName, $groupType)
{
$stateGroup = new Group();
$stateGroup->setUsername($username);
$stateGroup->setManagerEmail('*****@*****.**');
$stateGroup->setOfficialName($officialName);
$stateGroup->setGroupType($groupType);
$generator = new SecureRandom();
$password = $generator->nextBytes(10);
$stateGroup->setPassword($password);
return $stateGroup;
}
public function createLocation(User $user, $ifnotexists = false)
{
if ($ifnotexists === false || $this->anyLocationExists($user) === false) {
$loc = new Location($user);
if ($loc !== null) {
$generator = new SecureRandom();
$loc->setPassword(bin2hex($generator->nextBytes(2)));
$loc->setCaption($this->translator->trans('Location') . " #" . ($this->totalCount($user) + 1));
return $loc;
}
}
return null;
}
public function createID(User $user, $ifnotexists = false)
{
if ($ifnotexists === false || $this->anyIdExists($user) === false) {
$aid = new AccessID($user);
if ($aid !== null) {
$generator = new SecureRandom();
$aid->setPassword(bin2hex($generator->nextBytes(4)));
$aid->setCaption($this->translator->trans('Access Identifier') . " #" . ($this->totalCount($user) + 1));
return $aid;
}
}
return null;
}
/**
* @Route("/pwdgen/{len}", name="_ajax_pwdgen")
*/
public function pwdgenAction($len)
{
$len = intval($len);
$pwd = '';
$success = false;
$len = (int) ($len / 2);
if ($len > 0) {
$generator = new SecureRandom();
$pwd = bin2hex($generator->nextBytes($len));
$success = true;
}
return AjaxController::jsonResponse($success, array("pwd" => $pwd));
}
/**
* @Route("/redirect_sso", name="redirect_sso")
*/
public function redirectAction(Request $request)
{
$ssoUrl = "https://login.eveonline.com/oauth/authorize/";
$gen = new SecureRandom();
$nonce = md5($gen->nextBytes(10));
$session = $this->get('session');
$session->set('eve_sso_nonce', $nonce);
$params = ['response_type' => 'code', 'redirect_uri' => $this->generateUrl('sso_callback', [], true), 'scope' => "", 'client_id' => $this->container->getParameter('eve_client_id'), 'state' => $nonce];
$pieces = [];
foreach ($params as $k => $v) {
$pieces[] = "{$k}={$v}";
}
$fullUrl = $ssoUrl . '?' . implode("&", $pieces);
return $this->redirect($fullUrl);
}
private function creatGroup($username, $password, $officialName, $groupType, $parent = null)
{
$stateGroup = new Group();
$stateGroup->setUsername($username);
$stateGroup->setManagerEmail(self::COMMON_STATE_GROUP_EMAIL);
$stateGroup->setOfficialName($officialName);
$stateGroup->setGroupType($groupType);
$stateGroup->setParent($parent);
$stateGroup->setLocationName($username);
$generator = new SecureRandom();
$factory = $this->container->get('security.encoder_factory');
$encoder = $factory->getEncoder($stateGroup);
$password = $encoder->encodePassword(sha1($generator->nextBytes(10)), $stateGroup->getSalt());
$stateGroup->setPassword($password);
return $stateGroup;
}
/**
* @param User $user
* @param string $newPassword
*
* @return User
*/
public function changePassword(User $user, $newPassword)
{
$encoder = $this->encoderFactory->getEncoder($user);
$salt = bin2hex($this->secureRandom->nextBytes(16));
$encodedPassword = $encoder->encodePassword($newPassword, $salt);
$user->setSalt($salt);
$user->setPassword($encodedPassword);
return $user;
}
/**
* Seeds `mt_rand()` function.
*
* @see mt_srand()
* @see mt_rand()
*/
private function seedRandom()
{
if ($this->seeded) {
return;
}
$bytes = $this->secureRandom->nextBytes(4);
$seed = (int) base_convert(bin2hex($bytes), 16, 10) - 2147483647;
mt_srand($seed);
$this->seeded = true;
}
public function postUsersAction(Request $request)
{
return $this->sendRegistrationEmail();
$userManager = $this->get('fos_user.user_manager');
$user = $userManager->createUser();
$form = $this->createForm(new UserType(), $user);
$form->submit($request->request->get($form->getName()));
if ($form->isValid()) {
// if ($userManager->findUserByUsernameOrEmail($user->getEmail())) {
// throw new \Exception('Un utilisateur avec cette adresse email existe déjà.');
// }
$user->setUsername($user->getEmail());
$generator = new SecureRandom();
$user->setPlainPassword($generator->nextBytes(10));
// $userManager->updateUser($user);
return $user;
}
return $this->view($form, 400);
}
/**
* Creates a new TipoServicio entity.
*
*/
public function createAction(Request $request)
{
$entity = new Usuario();
$generator = new SecureRandom();
// $form = $this->createCreateForm($humanReadableString);
$form = $this->createCreateForm($entity);
//var_dump($entity);
$form->handleRequest($request);
$humanReadableString = bin2hex($generator->nextBytes(7));
$factory = $this->get('security.encoder_factory');
$encoder = $factory->getEncoder($entity);
$password = $encoder->encodePassword($humanReadableString, $entity->getSalt());
$entity->setPassword($password);
$entity->setNombre($entity->getNombre());
// var_dump($password);die;
// $entity->setPassword($humanReadableString);
$entity->setActivo(1);
if ($form->isValid()) {
$em = $this->getDoctrine()->getManager();
$em->persist($entity);
//var_dump($entity);
try {
// llamaral metodo enviar email en la controladora email y ponerleel usuario y la contrase�a generada
// aleatoriamente para que el usuario la reciba
$name = $entity->getNombre();
$password = $entity->getPassword();
$email = $entity->getCorreo();
$this->forward('sisconeeAppBundle:Email:SendEmail', array('name' => $name, 'password' => $humanReadableString, 'email' => $email));
$em->flush();
//Register Log ()
$data = $entity->getCorreo() . ',' . $entity->getNombre() . ',' . $entity->getRol() . ',' . $entity->getUsername() . ',' . $entity->getEntidad();
$em->getRepository('sisconeeAppBundle:Trazas')->persistLog('Añadido', 'user', $entity->getId(), $data, $this->getCurrentUser());
$this->get('session')->getFlashBag()->add('notice', 'Los cambios fueron actualizados.');
} catch (\Exception $e) {
$this->get('session')->getFlashBag()->add('error', 'El usuario no pudo ser insertado. Ya existe un registro con ese nombre.');
}
return $this->redirect($this->generateUrl('administracion_usuario', array('id' => $entity->getId())));
}
return $this->render('sisconeeAdministracionBundle:Usuario:new.html.twig', array('entity' => $entity, 'form' => $form->createView()));
}
/**
* @param Schema $schema
*/
public function up(Schema $schema)
{
$this->abortIf($this->connection->getDatabasePlatform()->getName() != 'mysql', 'Migration can only be executed safely on \'mysql\'.');
$this->addSql('ALTER TABLE `user` ADD ics_feed_key VARCHAR(64) NOT NULL');
$sql = 'SELECT user_id FROM `user`';
$rows = $this->connection->executeQuery($sql)->fetchAll();
if (count($rows)) {
$generator = new SecureRandom();
$updates = array_map(function ($arr) use($generator) {
$random = $generator->nextBytes(128);
$key = $arr['user_id'] . microtime() . '_' . $random;
$key = hash('sha256', $key);
return "WHEN {$arr['user_id']} THEN '{$key}'";
}, $rows);
//bulk update all the records to avoide a mess in the output
$sql = 'UPDATE `user` SET ics_feed_key = (CASE user_id ';
$sql .= implode($updates, ' ');
$sql .= 'END)';
$this->addSql($sql);
}
$this->addSql('CREATE UNIQUE INDEX UNIQ_8D93D649AAB338A6 ON `user` (ics_feed_key)');
}
protected function execute(InputInterface $input, OutputInterface $output)
{
// New User
$user = new User();
// Provided Info
$name = $input->getArgument('name');
$email = $input->getArgument('email');
$password = $input->getArgument('password');
// Generate Salt
$generator = new SecureRandom();
$salt = md5($generator->nextBytes(32));
// User entity
$user->setName($name)->setEmail($email)->setSalt($salt);
// Encode Password
$encoder = $this->getContainer()->get('security.password_encoder');
$encodedPassword = $encoder->encodePassword($user, $password);
$user->setPassword($encodedPassword);
// Save User
$manager = $this->getContainer()->get('doctrine')->getManager();
$manager->persist($user);
$manager->flush();
$output->writeln('User created');
}
/**
* @Route("/enregistrement", name="register_user")
*/
public function registerUserAction(Request $request)
{
$user = new User();
$createUserForm = $this->createForm(new RegisterType(), $user);
$createUserForm->handleRequest($request);
if ($createUserForm->isValid()) {
$generator = new SecureRandom();
$salt = bin2hex($generator->nextBytes(50));
$token = bin2hex($generator->nextBytes(50));
$user->setSalt($salt);
$user->setToken($token);
$user->setRoles(array("ROLE_USER"));
$encoder = $this->get("security.password_encoder");
$encodedPassword = $encoder->encodePassword($user, $user->getPassword());
$user->setPassword($encodedPassword);
$em = $this->get("doctrine")->getManager();
$em->persist($user);
$em->flush();
return $this->redirectToRoute('login');
}
$params = array("createUserForm" => $createUserForm->createView());
return $this->render("user/register_user.html.twig", $params);
}
/**
* Reset user password
*
* @Route("/resetPassword/{id}", name="admin_user_creation_resetpassword")
* @Method("GET")
*/
public function resetPasswordAction($id)
{
$em = $this->getDoctrine()->getManager();
$entity = $em->getRepository('YellowknifeSecurityBundle:User')->findOneBy(array('id' => $id));
$generator = new SecureRandom();
$password = bin2hex($generator->nextBytes(4));
$message = \Swift_Message::newInstance()->setSubject('Password Lion CRM')->setFrom('*****@*****.**')->setTo($entity->getEmail())->setBody('User: '******' Password: '******'text/plain');
$this->container->get('mailer')->send($message);
$encoder = $this->container->get('security.password_encoder');
$encoded = $encoder->encodePassword($entity, $password);
$entity->setPassword($encoded);
$this->get('session')->getFlashBag()->add('notice', 'Password sent to: ' . $entity->getEmail());
$em->flush();
return $this->redirect($this->generateUrl('admin_user'));
}
private function setSessionToken()
{
$generator = new SecureRandom();
$this->strSessionToken = $generator->nextBytes(10);
}
/**
* saltを生成する
*
* @param $byte
* @return string
*/
public function createSalt($byte)
{
$generator = new SecureRandom();
return bin2hex($generator->nextBytes($byte));
}
public function generateKey()
{
$generator = new SecureRandom();
return sha1($generator->nextBytes(250));
}
/**
* @inheritdoc
*/
public function generateIcsFeedKey()
{
$generator = new SecureRandom();
$random = $generator->nextBytes(128);
// prepend user id to avoid a conflict
// and current time to give some more uniqueness
$key = $this->getId() . microtime() . '_' . $random;
// hash the string to give consistent length and URL safe characters
$this->icsFeedKey = hash('sha256', $key);
}
public function generateToken($x)
{
$generator = new SecureRandom();
return $generator->nextBytes($x);
}
