/** * Constructs dynamic node type * * @param string */ public function __construct($label) { $this->label = $label; if (empty($this->uuid)) { $this->uuid = $label . Algorithms::generateRandomString(6); } }
/** * After returning advice, making sure we have an UUID for each and every entity. * * @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint The current join point * @return void * @Flow\Before("TYPO3\Flow\Persistence\Aspect\PersistenceMagicAspect->isEntity && method(.*->(__construct|__clone)()) && filter(TYPO3\Flow\Persistence\Doctrine\Mapping\Driver\FlowAnnotationDriver)") */ public function generateUuid(JoinPointInterface $joinPoint) { /** @var $proxy \TYPO3\Flow\Persistence\Aspect\PersistenceMagicInterface */ $proxy = $joinPoint->getProxy(); ObjectAccess::setProperty($proxy, 'Persistence_Object_Identifier', Algorithms::generateUUID(), true); $this->persistenceManager->registerNewObject($proxy); }
/** * @param Schema $schema * @return void */ public function down(Schema $schema) { $this->abortIf($this->connection->getDatabasePlatform()->getName() != "postgresql"); $this->addSql("ALTER TABLE typo3_neos_eventlog_domain_model_event DROP CONSTRAINT fk_30ab3a75b684c08"); $this->addSql("ALTER TABLE typo3_neos_eventlog_domain_model_event DROP CONSTRAINT typo3_neos_eventlog_domain_model_event_pkey"); $this->addSql("ALTER TABLE typo3_neos_eventlog_domain_model_event ADD persistence_object_identifier VARCHAR(40) NULL"); $result = $this->connection->executeQuery("SELECT installed_version FROM pg_available_extensions WHERE name = 'uuid-ossp'"); if ($result->fetchColumn() !== NULL) { $this->addSql("UPDATE typo3_neos_eventlog_domain_model_event SET persistence_object_identifier = uuid_generate_v4()"); } else { $result = $this->connection->executeQuery("SELECT uid FROM typo3_neos_eventlog_domain_model_event"); while ($uid = $result->fetchColumn()) { $this->addSql("UPDATE typo3_neos_eventlog_domain_model_event SET persistence_object_identifier = '" . \TYPO3\Flow\Utility\Algorithms::generateUUID() . "' WHERE uid = " . $uid); } } $this->addSql("ALTER TABLE typo3_neos_eventlog_domain_model_event ALTER COLUMN persistence_object_identifier SET NOT NULL"); $this->addSql("ALTER TABLE typo3_neos_eventlog_domain_model_event ALTER uid DROP NOT NULL"); $this->addSql("ALTER TABLE typo3_neos_eventlog_domain_model_event ALTER parentevent TYPE VARCHAR(40) USING (parentevent::varchar)"); $this->addSql("ALTER TABLE typo3_neos_eventlog_domain_model_event ALTER parentevent DROP DEFAULT"); $this->addSql("WITH p AS (SELECT DISTINCT uid, persistence_object_identifier FROM typo3_neos_eventlog_domain_model_event) UPDATE typo3_neos_eventlog_domain_model_event SET parentevent = p.persistence_object_identifier FROM p WHERE parentevent IS NOT NULL AND p.uid = parentevent::integer"); $this->addSql("SELECT setval('typo3_neos_eventlog_domain_model_event_uid_seq', (SELECT MAX(uid) FROM typo3_neos_eventlog_domain_model_event)+1);"); $this->addSql("ALTER TABLE typo3_neos_eventlog_domain_model_event ALTER uid SET DEFAULT nextval('typo3_neos_eventlog_domain_model_event_uid_seq')"); $this->addSql("ALTER TABLE typo3_neos_eventlog_domain_model_event ADD PRIMARY KEY (persistence_object_identifier)"); $this->addSql("ALTER TABLE typo3_neos_eventlog_domain_model_event ADD CONSTRAINT fk_30ab3a75b684c08 FOREIGN KEY (parentevent) REFERENCES typo3_neos_eventlog_domain_model_event (persistence_object_identifier) NOT DEFERRABLE INITIALLY IMMEDIATE"); }
/** * @param \TYPO3\Flow\Security\Account $login * @param string $name * @param string $imageId * @param string $imageId */ public function __construct($login, $name, $imageId) { $this->accountId = \TYPO3\Flow\Utility\Algorithms::generateUUID(); $this->creationDate = new \DateTime(); $this->login = $login; $this->name = trim($name); $this->imageId = trim($imageId); }
/** * Redirects to the Neos backend on the given site, passing a one-time login token * * @param Site $site * @return void */ public function switchSiteAction($site) { $token = Algorithms::generateRandomToken(32); $this->loginTokenCache->set($token, $this->currentSession->getId()); $siteUri = $this->linkingService->createSiteUri($this->controllerContext, $site); $loginUri = $this->controllerContext->getUriBuilder()->reset()->uriFor('tokenLogin', ['token' => $token], 'Login', 'TYPO3.Neos'); $this->redirectToUri($siteUri . $loginUri); }
/** * Generates a new key & saves it encrypted with a hashing strategy * * @param string $name * @return string * @throws \TYPO3\Flow\Security\Exception */ public function generateKey($name) { if (strlen($name) === 0) { throw new \TYPO3\Flow\Security\Exception('Required name argument was empty', 1334215474); } $password = \TYPO3\Flow\Utility\Algorithms::generateRandomString($this->passwordGenerationLength); $this->persistKey($name, $password); return $password; }
public function getMockFileResource($filename = 'test.jpg') { $hash = sha1(Algorithms::generateRandomBytes(40)); $resourcePointer = new \TYPO3\Flow\Resource\ResourcePointer($hash); $mockResource = $this->getAccessibleMock('TYPO3\\Flow\\Resource\\Resource', array('getResourcePointer')); $mockResource->expects($this->any())->method('getResourcePointer')->will($this->returnValue($resourcePointer)); $mockResource->_set('filename', $filename); return $mockResource; }
/** * Fetch the token or generate a new random token * * @return string */ public function getToken() { $token = $this->cache->get($this->tokenName); if ($token === FALSE) { $token = Algorithms::generateRandomToken(20); $this->storeToken($token); } return $token; }
/** * Generate a number of random identifiers * * @param integer $count * @return void */ public function generateRandomIdentifiersCommand($count = 10) { $this->outputLine('Here are your random identifiers:'); $this->outputLine(''); for ($i = 0; $i < 10; $i++) { $this->outputLine(Algorithms::generateUUID()); } $this->outputLine(''); $this->outputLine('Make sure you always use an identifier once ;-)'); }
/** * Constructs dynamic property * * @param string $label * @param DynamicNodeType $dynamicNodeType * @param string $placeholder * @param string $defaultValue */ public function __construct($label, $dynamicNodeType, $placeholder, $defaultValue) { $this->label = $label; $this->dynamicNodeType = $dynamicNodeType; $this->placeholder = $placeholder; $this->defaultValue = $defaultValue; if (empty($this->uuid)) { $this->uuid = $label . Algorithms::generateRandomString(6); } }
/** * Redirects to the Neos backend on the given hostname, passing a one-time login token * * @param string $hostname * @return void */ public function switchSiteAction($hostname) { $token = Algorithms::generateRandomToken(32); $this->loginTokenCache->set($token, $this->currentSession->getId()); $requestUri = $this->controllerContext->getRequest()->getHttpRequest()->getUri(); $baseUri = $this->controllerContext->getRequest()->getHttpRequest()->getBaseUri(); $uri = $this->controllerContext->getUriBuilder()->reset()->uriFor('tokenLogin', ['token' => $token], 'Login', 'TYPO3.Neos'); $uri = sprintf('%s://%s%s%s', $requestUri->getScheme(), $hostname, rtrim($baseUri->getPath(), '/'), $uri); $this->redirectToUri($uri); }
/** * @test */ public function createNodeFromTemplateUsesIdentifierFromTemplate() { $identifier = \TYPO3\Flow\Utility\Algorithms::generateUUID(); $template = new \TYPO3\TYPO3CR\Domain\Model\NodeTemplate(); $template->setName('new-node'); $template->setIdentifier($identifier); $rootNode = $this->context->getRootNode(); $newNode = $rootNode->createNodeFromTemplate($template); $this->assertSame($identifier, $newNode->getIdentifier()); }
/** * Generate UUIDs in PHP if the uuid-ossp extension is not installed. * * @param Schema $schema * @return void */ public function preDown(Schema $schema) { $result = $this->connection->executeQuery("SELECT installed_version FROM pg_available_extensions WHERE name = 'uuid-ossp'"); if ($result->fetchColumn() === NULL) { $this->connection->executeUpdate("ALTER TABLE typo3_typo3cr_domain_model_workspace ADD persistence_object_identifier VARCHAR(40)"); $result = $this->connection->executeQuery('SELECT name FROM typo3_typo3cr_domain_model_workspace'); foreach ($result->fetchAll() as $workspace) { $this->connection->update('typo3_typo3cr_domain_model_workspace', array('persistence_object_identifier' => \TYPO3\Flow\Utility\Algorithms::generateUUID()), array('name' => $workspace['name'])); } } }
/** * Initialize */ protected function initialize() { $this->logPrefix = $this->logPrefix ?: Algorithms::generateRandomString(12); $contextConfiguration = ['workspaceName' => 'live', 'invisibleContentShown' => TRUE]; $context = $this->contextFactory->create($contextConfiguration); $this->rootNode = $context->getRootNode(); $siteNodePath = $this->options['siteNodePath']; $this->siteNode = $this->rootNode->getNode($siteNodePath); if ($this->siteNode === NULL) { throw new Exception(sprintf('Site node not found (%s)', $siteNodePath), 1425077201); } }
/** * Sends an email to a user with the new password * * @param \TYPO3\Flow\Security\Account $account * @param array $settings * @param string $newEnteredPassword * @return boolean $success */ public function sendMail(Account $account, $settings, $newEnteredPassword = NULL) { if ($newEnteredPassword !== NULL) { $newPassword = $newEnteredPassword; } else { $newPassword = $this->algorithms->generateRandomString(10); $account->setCredentialsSource($this->hashService->hashPassword($newPassword, 'default')); $this->accountRepository->update($account); } // @TODO: Localize the email format $mailBody[] = 'Dear %1$s'; $mailBody[] = ''; $mailBody[] = 'Your password for First Visit.'; $mailBody[] = 'The password is %2$s'; $mailBody[] = ''; $mailBody[] = 'If you haven\'t requested this information, please change your password at once'; $mailBody[] = 'as others might be able to access your account'; $success = FALSE; $message = new SwiftMessage(); if ($message->setTo(array($account->getAccountIdentifier() => $account->getParty()->getName()))->setFrom(array($settings['PasswordRecovery']['Sender']['Email'] => $settings['PasswordRecovery']['Sender']['Name']))->setSubject($settings['PasswordRecovery']['Subject'])->setBody(vsprintf(implode(PHP_EOL, $mailBody), array($account->getParty()->getName(), $newPassword)))->send()) { $success = TRUE; } return $success; }
/** * Hash a password for storage using PBKDF2 and the configured parameters. * Will use a combination of a random dynamic salt and the given static salt. * * @param string $password Cleartext password that should be hashed * @param string $staticSalt Static salt that will be appended to the random dynamic salt * @return string A Base64 encoded string with the derived key (hashed password) and dynamic salt */ public function hashPassword($password, $staticSalt = null) { $dynamicSalt = UtilityAlgorithms::generateRandomString($this->dynamicSaltLength); $result = Algorithms::pbkdf2($password, $dynamicSalt . $staticSalt, $this->iterationCount, $this->derivedKeyLength, $this->algorithm); return base64_encode($dynamicSalt) . ',' . base64_encode($result); }
/** * Creates a BCrypt hash * * @param string $password The plaintext password to hash * @param string $staticSalt Optional static salt that will not be stored in the hashed password * @return string the result of the crypt() call */ public function hashPassword($password, $staticSalt = NULL) { $dynamicSalt = \TYPO3\Flow\Utility\Algorithms::generateRandomString(22, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./'); return crypt($password, '$2a$' . $this->cost . '$' . $dynamicSalt); }
/** * @param array $setting * @param string $logPrefix * @throws InvalidArgumentException */ public function __construct(array $setting, $logPrefix = NULL) { if (!isset($setting['__currentPresetName'])) { throw new InvalidArgumentException('Missing or invalid "__currentPresetName" in preset part settings', 1426156156); } $this->currentPresetName = $setting['__currentPresetName']; if (!isset($setting['__currentPartName'])) { throw new InvalidArgumentException('Missing or invalid "__currentPartName" in preset part settings', 1426156155); } $this->currentPartName = $setting['__currentPartName']; if (!isset($setting['label']) || !is_string($setting['label'])) { throw new InvalidArgumentException('Missing or invalid "Label" in preset part settings', 1426156157); } $this->label = (string) $setting['label']; if (!isset($setting['dataProviderClassName']) || !is_string($setting['dataProviderClassName'])) { throw new InvalidArgumentException('Missing or invalid "dataProviderClassName" in preset part settings', 1426156158); } $this->dataProviderClassName = (string) $setting['dataProviderClassName']; if (!isset($setting['importerClassName']) || !is_string($setting['importerClassName'])) { throw new InvalidArgumentException('Missing or invalid "dataProviderClassName" in preset part settings', 1426156159); } $this->importerClassName = (string) $setting['importerClassName']; $this->batchSize = isset($setting['batchSize']) ? (int) $setting['batchSize'] : NULL; $this->offset = isset($setting['batchSize']) ? 0 : NULL; $this->dataProviderOptions = isset($setting['dataProviderOptions']) ? $setting['dataProviderOptions'] : []; $this->currentBatch = 1; $this->logPrefix = $logPrefix ?: Algorithms::generateRandomString(12); }
/** * @test */ public function nodeWithRelatedEntitiesWillTakeCareOfAddingToPersistence() { $identifier = Algorithms::generateUUID(); $template = new NodeTemplate(); $template->setName('new-node'); $template->setIdentifier($identifier); $newEntity = new Fixtures\RelatedEntity(); $newEntity->setFavoritePlace('Reykjavik'); $anotherNewEntity = new Fixtures\RelatedEntity(); $anotherNewEntity->setFavoritePlace('Japan'); $template->setProperty('entity', array($newEntity, $anotherNewEntity)); $rootNode = $this->context->getRootNode(); $newNode = $rootNode->createNodeFromTemplate($template); $this->persistenceManager->persistAll(); $this->persistenceManager->clearState(); $this->inject($this->contextFactory, 'contextInstances', array()); $newLiveContext = $this->contextFactory->create(array('workspaceName' => 'live')); $newNodeAgain = $newLiveContext->getNode('/new-node'); $entityArray = $newNodeAgain->getProperty('entity'); $this->assertCount(2, $entityArray); $this->assertEquals('Japan', $entityArray[1]->getFavoritePlace()); }
/** * Batch process of the given preset * * @param string $preset * @param string $parts */ public function batchCommand($preset, $parts = NULL) { $this->startTime = microtime(TRUE); $parts = Arrays::trimExplode(',', $parts); $this->outputLine('Start import ...'); $logPrefix = Algorithms::generateRandomString(12); $presetSettings = Arrays::getValueByPath($this->settings, array('presets', $preset)); if (!is_array($presetSettings)) { $this->outputLine(sprintf('Preset "%s" not found ...', $preset)); $this->quit(1); } array_walk($presetSettings, function ($partSetting, $partName) use($preset, $logPrefix, $parts) { $this->elapsedTime = 0; $this->batchCounter = 0; $this->outputLine(); $this->outputFormatted(sprintf('<b>%s</b>', $partSetting['label'])); $partSetting['__currentPresetName'] = $preset; $partSetting['__currentPartName'] = $partName; $partSetting = new PresetPartDefinition($partSetting, $logPrefix); if ($parts !== array() && !in_array($partName, $parts)) { $this->outputLine('Skipped'); return; } if ($partSetting->getBatchSize()) { while (($count = $this->executeCommand($partSetting)) > 0) { $partSetting->nextBatch(); } } else { $this->executeCommand($partSetting); } }); $this->outputLine(); $this->outputLine('Import finished'); }
/** * Returns the encryption key from the persistent cache or Data/Persistent directory. If none exists, a new * encryption key will be generated and stored in the cache. * * @return string The configured encryption key stored in Data/Persistent/EncryptionKey */ protected function getEncryptionKey() { if ($this->encryptionKey === NULL) { $this->encryptionKey = $this->cache->get('encryptionKey'); } if ($this->encryptionKey === FALSE && file_exists(FLOW_PATH_DATA . 'Persistent/EncryptionKey')) { $this->encryptionKey = file_get_contents(FLOW_PATH_DATA . 'Persistent/EncryptionKey'); } if ($this->encryptionKey === FALSE) { $this->encryptionKey = bin2hex(\TYPO3\Flow\Utility\Algorithms::generateRandomBytes(96)); $this->cache->set('encryptionKey', $this->encryptionKey); } return $this->encryptionKey; }
/** * Saves the given array as a node data entity without using the ORM. * * If the node data already exists (same dimensions, same identifier, same workspace) * it is replaced. * * @param array $nodeData node data to save as an associative array ( $column_name => $value ) * @throws ImportException * @return void */ protected function persistNodeData($nodeData) { if ($nodeData['workspace'] !== 'live') { throw new ImportException('Saving NodeData with workspace != "live" using direct SQL not supported yet. Workspace is "' . $nodeData['workspace'] . '".'); } if ($nodeData['path'] === '/') { return; } // cleanup old data /** @var \Doctrine\DBAL\Connection $connection */ $connection = $this->entityManager->getConnection(); // prepare node dimensions $dimensionValues = $nodeData['dimensionValues']; $dimensionsHash = Utility::sortDimensionValueArrayAndReturnDimensionsHash($dimensionValues); $jsonPropertiesDataTypeHandler = JsonArrayType::getType(JsonArrayType::FLOW_JSON_ARRAY); // post-process node data $nodeData['dimensionsHash'] = $dimensionsHash; $nodeData['dimensionValues'] = $jsonPropertiesDataTypeHandler->convertToDatabaseValue($dimensionValues, $connection->getDatabasePlatform()); $nodeData['properties'] = $jsonPropertiesDataTypeHandler->convertToDatabaseValue($nodeData['properties'], $connection->getDatabasePlatform()); $nodeData['accessRoles'] = $jsonPropertiesDataTypeHandler->convertToDatabaseValue($nodeData['accessRoles'], $connection->getDatabasePlatform()); $connection->executeQuery('DELETE FROM typo3_typo3cr_domain_model_nodedimension' . ' WHERE nodedata IN (' . ' SELECT persistence_object_identifier FROM typo3_typo3cr_domain_model_nodedata' . ' WHERE identifier = :identifier' . ' AND workspace = :workspace' . ' AND dimensionshash = :dimensionsHash' . ' )', array('identifier' => $nodeData['identifier'], 'workspace' => $nodeData['workspace'], 'dimensionsHash' => $nodeData['dimensionsHash'])); /** @var \Doctrine\ORM\QueryBuilder $queryBuilder */ $queryBuilder = $this->entityManager->createQueryBuilder(); $queryBuilder->delete()->from('TYPO3\\TYPO3CR\\Domain\\Model\\NodeData', 'n')->where('n.identifier = :identifier')->andWhere('n.dimensionsHash = :dimensionsHash')->andWhere('n.workspace = :workspace')->setParameter('identifier', $nodeData['identifier'])->setParameter('workspace', $nodeData['workspace'])->setParameter('dimensionsHash', $nodeData['dimensionsHash']); $queryBuilder->getQuery()->execute(); // insert new data // we need to use executeUpdate to execute the INSERT -- else the data types are not taken into account. // That's why we build a DQL INSERT statement which is then executed. $queryParts = array(); $queryArguments = array(); $queryTypes = array(); foreach ($this->nodeDataPropertyNames as $propertyName => $propertyConfig) { if (isset($nodeData[$propertyName])) { $queryParts[$propertyName] = ':' . $propertyName; $queryArguments[$propertyName] = $nodeData[$propertyName]; if (isset($propertyConfig['columnType'])) { $queryTypes[$propertyName] = $propertyConfig['columnType']; } } } $connection->executeUpdate('INSERT INTO typo3_typo3cr_domain_model_nodedata (' . implode(', ', array_keys($queryParts)) . ') VALUES (' . implode(', ', $queryParts) . ')', $queryArguments, $queryTypes); foreach ($dimensionValues as $dimension => $values) { foreach ($values as $value) { $nodeDimension = array('persistence_object_identifier' => Algorithms::generateUUID(), 'nodedata' => $nodeData['Persistence_Object_Identifier'], 'name' => $dimension, 'value' => $value); $connection->insert('typo3_typo3cr_domain_model_nodedimension', $nodeDimension); } } }
/** * @test * @dataProvider randomStringCharactersDataProvider */ public function generateRandomStringGeneratesOnlyDefinedCharactersRange($regularExpression, $charactersClass) { $this->assertRegExp($regularExpression, Algorithms::generateRandomString(64, $charactersClass)); }
/** * Generates and propagates a new session ID and transfers all existing data * to the new session. * * @return string The new session ID * @throws \TYPO3\Flow\Session\Exception\SessionNotStartedException * @throws \TYPO3\Flow\Session\Exception\OperationNotSupportedException * @api */ public function renewId() { if ($this->started !== true) { throw new \TYPO3\Flow\Session\Exception\SessionNotStartedException('Tried to renew the session identifier, but the session has not been started yet.', 1351182429); } if ($this->remote === true) { throw new \TYPO3\Flow\Session\Exception\OperationNotSupportedException(sprintf('Tried to renew the session identifier on a remote session (%s).', $this->sessionIdentifier), 1354034230); } $this->removeSessionMetaDataCacheEntry($this->sessionIdentifier); $this->sessionIdentifier = Algorithms::generateRandomString(32); $this->writeSessionMetaDataCacheEntry(); $this->sessionCookie->setValue($this->sessionIdentifier); return $this->sessionIdentifier; }
/** * Constructs this node data container * * Creating new nodes by instantiating NodeData is not part of the public API! * The content repository needs to properly integrate new nodes into the node * tree and therefore you must use createNode() or createNodeFromTemplate() * in a Node object which will internally create a NodeData object. * * @param string $path Absolute path of this node * @param \TYPO3\TYPO3CR\Domain\Model\Workspace $workspace The workspace this node will be contained in * @param string $identifier The node identifier (not the persistence object identifier!). Specifying this only makes sense while creating corresponding nodes * @param array $dimensions An array of dimension name to dimension values */ public function __construct($path, Workspace $workspace, $identifier = null, array $dimensions = null) { parent::__construct(); $this->creationDateTime = new \DateTime(); $this->lastModificationDateTime = new \DateTime(); $this->setPath($path, false); $this->workspace = $workspace; $this->identifier = $identifier === null ? Algorithms::generateUUID() : $identifier; $this->dimensions = new ArrayCollection(); if ($dimensions !== null) { foreach ($dimensions as $dimensionName => $dimensionValues) { foreach ($dimensionValues as $dimensionValue) { $this->dimensions->add(new NodeDimension($this, $dimensionName, $dimensionValue)); } } } $this->buildDimensionValues(); }
/** * @return string The configured encryption key stored in Data/Persistent/EncryptionKey * @throws \TYPO3\Flow\Security\Exception\MissingConfigurationException */ protected function getEncryptionKey() { if ($this->encryptionKey === NULL) { if (!file_exists(FLOW_PATH_DATA . 'Persistent/EncryptionKey')) { file_put_contents(FLOW_PATH_DATA . 'Persistent/EncryptionKey', bin2hex(\TYPO3\Flow\Utility\Algorithms::generateRandomBytes(96))); } $this->encryptionKey = file_get_contents(FLOW_PATH_DATA . 'Persistent/EncryptionKey'); if ($this->encryptionKey === FALSE || $this->encryptionKey === '') { throw new \TYPO3\Flow\Security\Exception\MissingConfigurationException('No encryption key for the HashService was found and none could be created at "' . FLOW_PATH_DATA . 'Persistent/EncryptionKey"', 1258991855); } } return $this->encryptionKey; }
/** * Returns the current CSRF protection token. A new one is created when needed, depending on the configured CSRF * protection strategy. * * @return string * @Flow\Session(autoStart=true) */ public function getCsrfProtectionToken() { if ($this->initialized === false) { $this->initialize(); } if (count($this->csrfProtectionTokens) === 1 && $this->csrfProtectionStrategy !== self::CSRF_ONE_PER_URI) { reset($this->csrfProtectionTokens); return key($this->csrfProtectionTokens); } $newToken = Algorithms::generateRandomToken(16); $this->csrfProtectionTokens[$newToken] = true; return $newToken; }
/** * @param BadgeClass $badgeClass The badge class where this step is needed for an assertion * @param string $identifier An identifier for this step (unique per badge class), used to reference steps client- and server-side */ public function __construct(BadgeClass $badgeClass, $identifier) { $this->badgeClass = $badgeClass; $this->identifier = $identifier; $this->token = \TYPO3\Flow\Utility\Algorithms::generateUUID(); }
/** */ protected function createAndPersistTestEntity() { $testEntity = new Tweet(); $testEntity->setDate(new \DateTime()); $testEntity->setMessage('This is a test message ' . \TYPO3\Flow\Utility\Algorithms::generateRandomString(8)); $testEntity->setUsername('Zak McKracken' . \TYPO3\Flow\Utility\Algorithms::generateRandomString(8)); $this->testEntityRepository->add($testEntity); $this->persistenceManager->persistAll(); $this->persistenceManager->clearState(); return $testEntity; }
/** * Hash a password for storage using PBKDF2 and the configured parameters. * Will use a combination of a random dynamic salt and the given static salt. * * @param string $password Cleartext password that should be hashed * @param string $staticSalt Static salt that will be appended to the random dynamic salt * @return string A Base64 encoded string with the derived key (hashed password) and dynamic salt */ public function hashPassword($password, $staticSalt = null) { $dynamicSalt = \TYPO3\Flow\Utility\Algorithms::generateRandomBytes($this->dynamicSaltLength); $result = \TYPO3\Flow\Security\Cryptography\Algorithms::pbkdf2($password, $dynamicSalt . $staticSalt, $this->iterationCount, $this->derivedKeyLength, $this->algorithm); return base64_encode($dynamicSalt) . ',' . base64_encode($result); }