No OneTemporary
Actions

Size

41 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/people/storage/PhabricatorUser.php b/src/applications/people/storage/PhabricatorUser.php
	index b3e8aece53..ab9f4d332f 100644
	--- a/src/applications/people/storage/PhabricatorUser.php
	+++ b/src/applications/people/storage/PhabricatorUser.php
	@@ -1,804 +1,850 @@
	<?php

	final class PhabricatorUser
	extends PhabricatorUserDAO
	implements
	PhutilPerson,
	PhabricatorPolicyInterface,
	PhabricatorCustomFieldInterface {

	const SESSION_TABLE = 'phabricator_session';
	const NAMETOKEN_TABLE = 'user_nametoken';

	protected $phid;
	protected $userName;
	protected $realName;
	protected $sex;
	protected $translation;
	protected $passwordSalt;
	protected $passwordHash;
	protected $profileImagePHID;
	protected $timezoneIdentifier = '';

	protected $consoleEnabled = 0;
	protected $consoleVisible = 0;
	protected $consoleTab = '';

	protected $conduitCertificate;

	protected $isSystemAgent = 0;
	protected $isAdmin = 0;
	protected $isDisabled = 0;

	private $profileImage = null;
	private $profile = null;
	private $status = self::ATTACHABLE;
	private $preferences = null;
	private $omnipotent = false;
	private $customFields = array();

	protected function readField($field) {
	switch ($field) {
	case 'timezoneIdentifier':
	// If the user hasn't set one, guess the server's time.
	return nonempty(
	$this->timezoneIdentifier,
	date_default_timezone_get());
	// Make sure these return booleans.
	case 'isAdmin':
	return (bool)$this->isAdmin;
	case 'isDisabled':
	return (bool)$this->isDisabled;
	case 'isSystemAgent':
	return (bool)$this->isSystemAgent;
	default:
	return parent::readField($field);
	}
	}

	public function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_PARTIAL_OBJECTS => true,
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorPeoplePHIDTypeUser::TYPECONST);
	}

	public function setPassword(PhutilOpaqueEnvelope $envelope) {
	if (!$this->getPHID()) {
	throw new Exception(
	"You can not set a password for an unsaved user because their PHID ".
	"is a salt component in the password hash.");
	}

	if (!strlen($envelope->openEnvelope())) {
	$this->setPasswordHash('');
	} else {
	$this->setPasswordSalt(md5(mt_rand()));
	$hash = $this->hashPassword($envelope);
	$this->setPasswordHash($hash);
	}
	return $this;
	}

	// To satisfy PhutilPerson.
	public function getSex() {
	return $this->sex;
	}

	public function getTranslation() {
	try {
	if ($this->translation &&
	class_exists($this->translation) &&
	is_subclass_of($this->translation, 'PhabricatorTranslation')) {
	return $this->translation;
	}
	} catch (PhutilMissingSymbolException $ex) {
	return null;
	}
	return null;
	}

	public function isLoggedIn() {
	return !($this->getPHID() === null);
	}

	public function save() {
	if (!$this->getConduitCertificate()) {
	$this->setConduitCertificate($this->generateConduitCertificate());
	}
	$result = parent::save();

	if ($this->profile) {
	$this->profile->save();
	}

	$this->updateNameTokens();

	id(new PhabricatorSearchIndexer())
	->indexDocumentByPHID($this->getPHID());

	return $result;
	}

	private function generateConduitCertificate() {
	return Filesystem::readRandomCharacters(255);
	}

	public function comparePassword(PhutilOpaqueEnvelope $envelope) {
	if (!strlen($envelope->openEnvelope())) {
	return false;
	}
	if (!strlen($this->getPasswordHash())) {
	return false;
	}
	$password_hash = $this->hashPassword($envelope);
	return ($password_hash === $this->getPasswordHash());
	}

	private function hashPassword(PhutilOpaqueEnvelope $envelope) {
	$hash = $this->getUsername().
	$envelope->openEnvelope().
	$this->getPHID().
	$this->getPasswordSalt();
	for ($ii = 0; $ii < 1000; $ii++) {
	$hash = md5($hash);
	}
	return $hash;
	}

	const CSRF_CYCLE_FREQUENCY = 3600;
	+ const CSRF_SALT_LENGTH = 8;
	const CSRF_TOKEN_LENGTH = 16;
	+ const CSRF_BREACH_PREFIX = 'B@';

	const EMAIL_CYCLE_FREQUENCY = 86400;
	const EMAIL_TOKEN_LENGTH = 24;

	- public function getCSRFToken($offset = 0) {
	+ private function getRawCSRFToken($offset = 0) {
	return $this->generateToken(
	time() + (self::CSRF_CYCLE_FREQUENCY * $offset),
	self::CSRF_CYCLE_FREQUENCY,
	PhabricatorEnv::getEnvConfig('phabricator.csrf-key'),
	self::CSRF_TOKEN_LENGTH);
	}

	- public function validateCSRFToken($token) {
	+ /**
	+ * @phutil-external-symbol class PhabricatorStartup
	+ */
	+ public function getCSRFToken() {
	+ $salt = PhabricatorStartup::getGlobal('csrf.salt');
	+ if (!$salt) {
	+ $salt = Filesystem::readRandomCharacters(self::CSRF_SALT_LENGTH);
	+ PhabricatorStartup::setGlobal('csrf.salt', $salt);
	+ }

	+ // Generate a token hash to mitigate BREACH attacks against SSL. See
	+ // discussion in T3684.
	+ $token = $this->getRawCSRFToken();
	+ $hash = PhabricatorHash::digest($token, $salt);
	+ return 'B@'.$salt.substr($hash, 0, self::CSRF_TOKEN_LENGTH);
	+ }
	+
	+ public function validateCSRFToken($token) {
	if (!$this->getPHID()) {
	return true;
	}

	+ $salt = null;
	+
	+ $version = 'plain';
	+
	+ // This is a BREACH-mitigating token. See T3684.
	+ $breach_prefix = self::CSRF_BREACH_PREFIX;
	+ $breach_prelen = strlen($breach_prefix);
	+
	+ if (!strncmp($token, $breach_prefix, $breach_prelen)) {
	+ $version = 'breach';
	+ $salt = substr($token, $breach_prelen, self::CSRF_SALT_LENGTH);
	+ $token = substr($token, $breach_prelen + self::CSRF_SALT_LENGTH);
	+ }
	+
	// When the user posts a form, we check that it contains a valid CSRF token.
	// Tokens cycle each hour (every CSRF_CYLCE_FREQUENCY seconds) and we accept
	// either the current token, the next token (users can submit a "future"
	// token if you have two web frontends that have some clock skew) or any of
	// the last 6 tokens. This means that pages are valid for up to 7 hours.
	// There is also some Javascript which periodically refreshes the CSRF
	// tokens on each page, so theoretically pages should be valid indefinitely.
	// However, this code may fail to run (if the user loses their internet
	// connection, or there's a JS problem, or they don't have JS enabled).
	// Choosing the size of the window in which we accept old CSRF tokens is
	// an issue of balancing concerns between security and usability. We could
	// choose a very narrow (e.g., 1-hour) window to reduce vulnerability to
	// attacks using captured CSRF tokens, but it's also more likely that real
	// users will be affected by this, e.g. if they close their laptop for an
	// hour, open it back up, and try to submit a form before the CSRF refresh
	// can kick in. Since the user experience of submitting a form with expired
	// CSRF is often quite bad (you basically lose data, or it's a big pain to
	// recover at least) and I believe we gain little additional protection
	// by keeping the window very short (the overwhelming value here is in
	// preventing blind attacks, and most attacks which can capture CSRF tokens
	// can also just capture authentication information [sniffing networks]
	// or act as the user [xss]) the 7 hour default seems like a reasonable
	// balance. Other major platforms have much longer CSRF token lifetimes,
	// like Rails (session duration) and Django (forever), which suggests this
	// is a reasonable analysis.
	$csrf_window = 6;

	for ($ii = -$csrf_window; $ii <= 1; $ii++) {
	- $valid = $this->getCSRFToken($ii);
	- if ($token == $valid) {
	- return true;
	+ $valid = $this->getRawCSRFToken($ii);
	+ switch ($version) {
	+ // TODO: We can remove this after the BREACH version has been in the
	+ // wild for a while.
	+ case 'plain':
	+ if ($token == $valid) {
	+ return true;
	+ }
	+ break;
	+ case 'breach':
	+ $digest = PhabricatorHash::digest($valid, $salt);
	+ if (substr($digest, 0, self::CSRF_TOKEN_LENGTH) == $token) {
	+ return true;
	+ }
	+ break;
	+ default:
	+ throw new Exception("Unknown CSRF token format!");
	}
	}

	return false;
	}

	private function generateToken($epoch, $frequency, $key, $len) {
	$time_block = floor($epoch / $frequency);
	$vec = $this->getPHID().$this->getPasswordHash().$key.$time_block;
	return substr(PhabricatorHash::digest($vec), 0, $len);
	}

	/**
	* Issue a new session key to this user. Phabricator supports different
	* types of sessions (like "web" and "conduit") and each session type may
	* have multiple concurrent sessions (this allows a user to be logged in on
	* multiple browsers at the same time, for instance).
	*
	* Note that this method is transport-agnostic and does not set cookies or
	* issue other types of tokens, it ONLY generates a new session key.
	*
	* You can configure the maximum number of concurrent sessions for various
	* session types in the Phabricator configuration.
	*
	* @param string Session type, like "web".
	* @return string Newly generated session key.
	*/
	public function establishSession($session_type) {
	$conn_w = $this->establishConnection('w');

	if (strpos($session_type, '-') !== false) {
	throw new Exception("Session type must not contain hyphen ('-')!");
	}

	// We allow multiple sessions of the same type, so when a caller requests
	// a new session of type "web", we give them the first available session in
	// "web-1", "web-2", ..., "web-N", up to some configurable limit. If none
	// of these sessions is available, we overwrite the oldest session and
	// reissue a new one in its place.

	$session_limit = 1;
	switch ($session_type) {
	case 'web':
	$session_limit = PhabricatorEnv::getEnvConfig('auth.sessions.web');
	break;
	case 'conduit':
	$session_limit = PhabricatorEnv::getEnvConfig('auth.sessions.conduit');
	break;
	default:
	throw new Exception("Unknown session type '{$session_type}'!");
	}

	$session_limit = (int)$session_limit;
	if ($session_limit <= 0) {
	throw new Exception(
	"Session limit for '{$session_type}' must be at least 1!");
	}

	// NOTE: Session establishment is sensitive to race conditions, as when
	// piping `arc` to `arc`:
	//
	// arc export ... \| arc paste ...
	//
	// To avoid this, we overwrite an old session only if it hasn't been
	// re-established since we read it.

	// Consume entropy to generate a new session key, forestalling the eventual
	// heat death of the universe.
	$session_key = Filesystem::readRandomCharacters(40);

	// Load all the currently active sessions.
	$sessions = queryfx_all(
	$conn_w,
	'SELECT type, sessionKey, sessionStart FROM %T
	WHERE userPHID = %s AND type LIKE %>',
	PhabricatorUser::SESSION_TABLE,
	$this->getPHID(),
	$session_type.'-');
	$sessions = ipull($sessions, null, 'type');
	$sessions = isort($sessions, 'sessionStart');

	$existing_sessions = array_keys($sessions);

	// UNGUARDED WRITES: Logging-in users don't have CSRF stuff yet.
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();

	$retries = 0;
	while (true) {


	// Choose which 'type' we'll actually establish, i.e. what number we're
	// going to append to the basic session type. To do this, just check all
	// the numbers sequentially until we find an available session.
	$establish_type = null;
	for ($ii = 1; $ii <= $session_limit; $ii++) {
	$try_type = $session_type.'-'.$ii;
	if (!in_array($try_type, $existing_sessions)) {
	$establish_type = $try_type;
	$expect_key = PhabricatorHash::digest($session_key);
	$existing_sessions[] = $try_type;

	// Ensure the row exists so we can issue an update below. We don't
	// care if we race here or not.
	queryfx(
	$conn_w,
	'INSERT IGNORE INTO %T (userPHID, type, sessionKey, sessionStart)
	VALUES (%s, %s, %s, 0)',
	self::SESSION_TABLE,
	$this->getPHID(),
	$establish_type,
	PhabricatorHash::digest($session_key));
	break;
	}
	}

	// If we didn't find an available session, choose the oldest session and
	// overwrite it.
	if (!$establish_type) {
	$oldest = reset($sessions);
	$establish_type = $oldest['type'];
	$expect_key = $oldest['sessionKey'];
	}

	// This is so that we'll only overwrite the session if it hasn't been
	// refreshed since we read it. If it has, the session key will be
	// different and we know we're racing other processes. Whichever one
	// won gets the session, we go back and try again.

	queryfx(
	$conn_w,
	'UPDATE %T SET sessionKey = %s, sessionStart = UNIX_TIMESTAMP()
	WHERE userPHID = %s AND type = %s AND sessionKey = %s',
	self::SESSION_TABLE,
	PhabricatorHash::digest($session_key),
	$this->getPHID(),
	$establish_type,
	$expect_key);

	if ($conn_w->getAffectedRows()) {
	// The update worked, so the session is valid.
	break;
	} else {
	// We know this just got grabbed, so don't try it again.
	unset($sessions[$establish_type]);
	}

	if (++$retries > $session_limit) {
	throw new Exception("Failed to establish a session!");
	}
	}

	$log = PhabricatorUserLog::newLog(
	$this,
	$this,
	PhabricatorUserLog::ACTION_LOGIN);
	$log->setDetails(
	array(
	'session_type' => $session_type,
	'session_issued' => $establish_type,
	));
	$log->setSession($session_key);
	$log->save();

	return $session_key;
	}

	public function destroySession($session_key) {
	$conn_w = $this->establishConnection('w');
	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE userPHID = %s AND sessionKey = %s',
	self::SESSION_TABLE,
	$this->getPHID(),
	PhabricatorHash::digest($session_key));
	}

	private function generateEmailToken(
	PhabricatorUserEmail $email,
	$offset = 0) {

	$key = implode(
	'-',
	array(
	PhabricatorEnv::getEnvConfig('phabricator.csrf-key'),
	$this->getPHID(),
	$email->getVerificationCode(),
	));

	return $this->generateToken(
	time() + ($offset * self::EMAIL_CYCLE_FREQUENCY),
	self::EMAIL_CYCLE_FREQUENCY,
	$key,
	self::EMAIL_TOKEN_LENGTH);
	}

	public function validateEmailToken(
	PhabricatorUserEmail $email,
	$token) {
	for ($ii = -1; $ii <= 1; $ii++) {
	$valid = $this->generateEmailToken($email, $ii);
	if ($token == $valid) {
	return true;
	}
	}
	return false;
	}

	public function getEmailLoginURI(PhabricatorUserEmail $email = null) {
	if (!$email) {
	$email = $this->loadPrimaryEmail();
	if (!$email) {
	throw new Exception("User has no primary email!");
	}
	}
	$token = $this->generateEmailToken($email);
	$uri = PhabricatorEnv::getProductionURI('/login/etoken/'.$token.'/');
	$uri = new PhutilURI($uri);
	return $uri->alter('email', $email->getAddress());
	}

	public function attachUserProfile(PhabricatorUserProfile $profile) {
	$this->profile = $profile;
	return $this;
	}

	public function loadUserProfile() {
	if ($this->profile) {
	return $this->profile;
	}

	$profile_dao = new PhabricatorUserProfile();
	$this->profile = $profile_dao->loadOneWhere('userPHID = %s',
	$this->getPHID());

	if (!$this->profile) {
	$profile_dao->setUserPHID($this->getPHID());
	$this->profile = $profile_dao;
	}

	return $this->profile;
	}

	public function loadPrimaryEmailAddress() {
	$email = $this->loadPrimaryEmail();
	if (!$email) {
	throw new Exception("User has no primary email address!");
	}
	return $email->getAddress();
	}

	public function loadPrimaryEmail() {
	return $this->loadOneRelative(
	new PhabricatorUserEmail(),
	'userPHID',
	'getPHID',
	'(isPrimary = 1)');
	}

	public function loadPreferences() {
	if ($this->preferences) {
	return $this->preferences;
	}

	$preferences = id(new PhabricatorUserPreferences())->loadOneWhere(
	'userPHID = %s',
	$this->getPHID());

	if (!$preferences) {
	$preferences = new PhabricatorUserPreferences();
	$preferences->setUserPHID($this->getPHID());

	$default_dict = array(
	PhabricatorUserPreferences::PREFERENCE_TITLES => 'glyph',
	PhabricatorUserPreferences::PREFERENCE_EDITOR => '',
	PhabricatorUserPreferences::PREFERENCE_MONOSPACED => '',
	PhabricatorUserPreferences::PREFERENCE_DARK_CONSOLE => 0);

	$preferences->setPreferences($default_dict);
	}

	$this->preferences = $preferences;
	return $preferences;
	}

	public function loadEditorLink($path, $line, $callsign) {
	$editor = $this->loadPreferences()->getPreference(
	PhabricatorUserPreferences::PREFERENCE_EDITOR);

	if (is_array($path)) {
	$multiedit = $this->loadPreferences()->getPreference(
	PhabricatorUserPreferences::PREFERENCE_MULTIEDIT);
	switch ($multiedit) {
	case '':
	$path = implode(' ', $path);
	break;
	case 'disable':
	return null;
	}
	}

	if ($editor) {
	return strtr($editor, array(
	'%%' => '%',
	'%f' => phutil_escape_uri($path),
	'%l' => phutil_escape_uri($line),
	'%r' => phutil_escape_uri($callsign),
	));
	}
	}

	private static function tokenizeName($name) {
	if (function_exists('mb_strtolower')) {
	$name = mb_strtolower($name, 'UTF-8');
	} else {
	$name = strtolower($name);
	}
	$name = trim($name);
	if (!strlen($name)) {
	return array();
	}
	return preg_split('/\s+/', $name);
	}

	/**
	* Populate the nametoken table, which used to fetch typeahead results. When
	* a user types "linc", we want to match "Abraham Lincoln" from on-demand
	* typeahead sources. To do this, we need a separate table of name fragments.
	*/
	public function updateNameTokens() {
	$tokens = array_merge(
	self::tokenizeName($this->getRealName()),
	self::tokenizeName($this->getUserName()));
	$tokens = array_unique($tokens);
	$table = self::NAMETOKEN_TABLE;
	$conn_w = $this->establishConnection('w');

	$sql = array();
	foreach ($tokens as $token) {
	$sql[] = qsprintf(
	$conn_w,
	'(%d, %s)',
	$this->getID(),
	$token);
	}

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE userID = %d',
	$table,
	$this->getID());
	if ($sql) {
	queryfx(
	$conn_w,
	'INSERT INTO %T (userID, token) VALUES %Q',
	$table,
	implode(', ', $sql));
	}
	}

	public function sendWelcomeEmail(PhabricatorUser $admin) {
	$admin_username = $admin->getUserName();
	$admin_realname = $admin->getRealName();
	$user_username = $this->getUserName();
	$is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');

	$base_uri = PhabricatorEnv::getProductionURI('/');

	$uri = $this->getEmailLoginURI();
	$body = <<<EOBODY
	Welcome to Phabricator!

	{$admin_username} ({$admin_realname}) has created an account for you.

	Username: {$user_username}

	To login to Phabricator, follow this link and set a password:

	{$uri}

	After you have set a password, you can login in the future by going here:

	{$base_uri}

	EOBODY;

	if (!$is_serious) {
	$body .= <<<EOBODY

	Love,
	Phabricator

	EOBODY;
	}

	$mail = id(new PhabricatorMetaMTAMail())
	->addTos(array($this->getPHID()))
	->setSubject('[Phabricator] Welcome to Phabricator')
	->setBody($body)
	->saveAndSend();
	}

	public function sendUsernameChangeEmail(
	PhabricatorUser $admin,
	$old_username) {

	$admin_username = $admin->getUserName();
	$admin_realname = $admin->getRealName();
	$new_username = $this->getUserName();

	$password_instructions = null;
	if (PhabricatorAuthProviderPassword::getPasswordProvider()) {
	$uri = $this->getEmailLoginURI();
	$password_instructions = <<<EOTXT
	If you use a password to login, you'll need to reset it before you can login
	again. You can reset your password by following this link:

	{$uri}

	And, of course, you'll need to use your new username to login from now on. If
	you use OAuth to login, nothing should change.

	EOTXT;
	}

	$body = <<<EOBODY
	{$admin_username} ({$admin_realname}) has changed your Phabricator username.

	Old Username: {$old_username}
	New Username: {$new_username}

	{$password_instructions}
	EOBODY;

	$mail = id(new PhabricatorMetaMTAMail())
	->addTos(array($this->getPHID()))
	->setSubject('[Phabricator] Username Changed')
	->setBody($body)
	->saveAndSend();
	}

	public static function describeValidUsername() {
	return 'Usernames must contain only numbers, letters, period, underscore '.
	'and hyphen, and can not end with a period.';
	}

	public static function validateUsername($username) {
	// NOTE: If you update this, make sure to update:
	//
	// - Remarkup rule for @mentions.
	// - Routing rule for "/p/username/".
	// - Unit tests, obviously.
	// - describeValidUsername() method, above.

	return (bool)preg_match('/^[a-zA-Z0-9._-]*[a-zA-Z0-9_-]$/', $username);
	}

	public static function getDefaultProfileImageURI() {
	return celerity_get_resource_uri('/rsrc/image/avatar.png');
	}

	public function attachStatus(PhabricatorUserStatus $status) {
	$this->status = $status;
	return $this;
	}

	public function getStatus() {
	$this->assertAttached($this->status);
	return $this->status;
	}

	public function hasStatus() {
	return $this->status !== self::ATTACHABLE;
	}

	public function attachProfileImageURI($uri) {
	$this->profileImage = $uri;
	return $this;
	}

	public function loadProfileImageURI() {
	if ($this->profileImage) {
	return $this->profileImage;
	}

	$src_phid = $this->getProfileImagePHID();

	if ($src_phid) {
	$file = id(new PhabricatorFile())->loadOneWhere('phid = %s', $src_phid);
	if ($file) {
	$this->profileImage = $file->getBestURI();
	}
	}

	if (!$this->profileImage) {
	$this->profileImage = self::getDefaultProfileImageURI();
	}

	return $this->profileImage;
	}

	public function getFullName() {
	return $this->getUsername().' ('.$this->getRealName().')';
	}

	public function __toString() {
	return $this->getUsername();
	}

	public static function loadOneWithEmailAddress($address) {
	$email = id(new PhabricatorUserEmail())->loadOneWhere(
	'address = %s',
	$address);
	if (!$email) {
	return null;
	}
	return id(new PhabricatorUser())->loadOneWhere(
	'phid = %s',
	$email->getUserPHID());
	}


	/* -( Omnipotence )-------------------------------------------------------- */


	/**
	* Returns true if this user is omnipotent. Omnipotent users bypass all policy
	* checks.
	*
	* @return bool True if the user bypasses policy checks.
	*/
	public function isOmnipotent() {
	return $this->omnipotent;
	}


	/**
	* Get an omnipotent user object for use in contexts where there is no acting
	* user, notably daemons.
	*
	* @return PhabricatorUser An omnipotent user.
	*/
	public static function getOmnipotentUser() {
	static $user = null;
	if (!$user) {
	$user = new PhabricatorUser();
	$user->omnipotent = true;
	$user->makeEphemeral();
	}
	return $user;
	}


	/* -( PhabricatorPolicyInterface )----------------------------------------- */


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return PhabricatorPolicies::POLICY_PUBLIC;
	case PhabricatorPolicyCapability::CAN_EDIT:
	return PhabricatorPolicies::POLICY_NOONE;
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return $this->getPHID() && ($viewer->getPHID() === $this->getPHID());
	}


	/* -( PhabricatorCustomFieldInterface )------------------------------------ */


	public function getCustomFieldSpecificationForRole($role) {
	return PhabricatorEnv::getEnvConfig('user.fields');
	}

	public function getCustomFieldBaseClass() {
	return 'PhabricatorUserCustomFieldInterface';
	}

	public function getCustomFields($role) {
	if (idx($this->customFields, $role) === null) {
	PhabricatorCustomField::raiseUnattachedException($this, $role);
	}
	return $this->customFields[$role];
	}

	public function attachCustomFields($role, array $fields) {
	$this->customFields[$role] = $fields;
	return $this;
	}

	}
	diff --git a/src/infrastructure/util/PhabricatorHash.php b/src/infrastructure/util/PhabricatorHash.php
	index 7167f5e792..dc86813b56 100644
	--- a/src/infrastructure/util/PhabricatorHash.php
	+++ b/src/infrastructure/util/PhabricatorHash.php
	@@ -1,57 +1,60 @@
	<?php

	final class PhabricatorHash {


	/**
	* Digest a string for general use, including use which relates to security.
	*
	* @param string Input string.
	* @return string 32-byte hexidecimal SHA1+HMAC hash.
	*/
	- public static function digest($string) {
	- $key = PhabricatorEnv::getEnvConfig('security.hmac-key');
	+ public static function digest($string, $key = null) {
	+ if ($key === null) {
	+ $key = PhabricatorEnv::getEnvConfig('security.hmac-key');
	+ }
	+
	if (!$key) {
	throw new Exception(
	"Set a 'security.hmac-key' in your Phabricator configuration!");
	}

	return hash_hmac('sha1', $string, $key);
	}


	/**
	* Digest a string for use in, e.g., a MySQL index. This produces a short
	* (12-byte), case-sensitive alphanumeric string with 72 bits of entropy,
	* which is generally safe in most contexts (notably, URLs).
	*
	* This method emphasizes compactness, and should not be used for security
	* related hashing (for general purpose hashing, see @{method:digest}).
	*
	* @param string Input string.
	* @return string 12-byte, case-sensitive alphanumeric hash of the string
	* which
	*/
	public static function digestForIndex($string) {
	$hash = sha1($string, $raw_output = true);

	static $map;
	if ($map === null) {
	$map = "0123456789".
	"abcdefghij".
	"klmnopqrst".
	"uvwxyzABCD".
	"EFGHIJKLMN".
	"OPQRSTUVWX".
	"YZ._";
	}

	$result = '';
	for ($ii = 0; $ii < 12; $ii++) {
	$result .= $map[(ord($hash[$ii]) & 0x3F)];
	}

	return $result;
	}

	}
	diff --git a/support/PhabricatorStartup.php b/support/PhabricatorStartup.php
	index d02d565ab2..79b2131def 100644
	--- a/support/PhabricatorStartup.php
	+++ b/support/PhabricatorStartup.php
	@@ -1,472 +1,474 @@
	<?php

	/**
	* Handle request startup, before loading the environment or libraries. This
	* class bootstraps the request state up to the point where we can enter
	* Phabricator code.
	*
	* NOTE: This class MUST NOT have any dependencies. It runs before libraries
	* load.
	*
	* @task info Accessing Request Information
	* @task hook Startup Hooks
	* @task apocalypse In Case Of Apocalypse
	* @task validation Validation
	*/
	final class PhabricatorStartup {

	private static $startTime;
	private static $globals = array();
	private static $capturingOutput;
	private static $rawInput;


	/* -( Accessing Request Information )-------------------------------------- */


	/**
	* @task info
	*/
	public static function getStartTime() {
	return self::$startTime;
	}


	/**
	* @task info
	*/
	public static function getMicrosecondsSinceStart() {
	return (int)(1000000 * (microtime(true) - self::getStartTime()));
	}


	/**
	* @task info
	*/
	public static function setGlobal($key, $value) {
	self::validateGlobal($key);

	self::$globals[$key] = $value;
	}


	/**
	* @task info
	*/
	public static function getGlobal($key, $default = null) {
	self::validateGlobal($key);

	if (!array_key_exists($key, self::$globals)) {
	return $default;
	}
	+
	return self::$globals[$key];
	}

	/**
	* @task info
	*/
	public static function getRawInput() {
	return self::$rawInput;
	}


	/* -( Startup Hooks )------------------------------------------------------ */


	/**
	* @task hook
	*/
	public static function didStartup() {
	self::$startTime = microtime(true);
	self::$globals = array();

	static $registered;
	if (!$registered) {
	// NOTE: This protects us against multiple calls to didStartup() in the
	// same request, but also against repeated requests to the same
	// interpreter state, which we may implement in the future.
	register_shutdown_function(array(__CLASS__, 'didShutdown'));
	$registered = true;
	}

	self::setupPHP();
	self::verifyPHP();

	self::normalizeInput();

	self::verifyRewriteRules();

	self::detectPostMaxSizeTriggered();

	self::beginOutputCapture();

	self::$rawInput = (string)file_get_contents('php://input');
	}


	/**
	* @task hook
	*/
	public static function didShutdown() {
	$event = error_get_last();

	if (!$event) {
	return;
	}

	switch ($event['type']) {
	case E_ERROR:
	case E_PARSE:
	case E_COMPILE_ERROR:
	break;
	default:
	return;
	}

	$msg = ">>> UNRECOVERABLE FATAL ERROR <<<\n\n";
	if ($event) {
	// Even though we should be emitting this as text-plain, escape things
	// just to be sure since we can't really be sure what the program state
	// is when we get here.
	$msg .= htmlspecialchars(
	$event['message']."\n\n".$event['file'].':'.$event['line'],
	ENT_QUOTES,
	'UTF-8');
	}

	// flip dem tables
	$msg .= "\n\n\n";
	$msg .= "\xe2\x94\xbb\xe2\x94\x81\xe2\x94\xbb\x20\xef\xb8\xb5\x20\xc2\xaf".
	"\x5c\x5f\x28\xe3\x83\x84\x29\x5f\x2f\xc2\xaf\x20\xef\xb8\xb5\x20".
	"\xe2\x94\xbb\xe2\x94\x81\xe2\x94\xbb";

	self::didFatal($msg);
	}

	public static function loadCoreLibraries() {
	$phabricator_root = dirname(dirname(__FILE__));
	$libraries_root = dirname($phabricator_root);

	$root = null;
	if (!empty($_SERVER['PHUTIL_LIBRARY_ROOT'])) {
	$root = $_SERVER['PHUTIL_LIBRARY_ROOT'];
	}

	ini_set(
	'include_path',
	$libraries_root.PATH_SEPARATOR.ini_get('include_path'));

	@include_once $root.'libphutil/src/__phutil_library_init__.php';
	if (!@constant('__LIBPHUTIL__')) {
	self::didFatal(
	"Unable to load libphutil. Put libphutil/ next to phabricator/, or ".
	"update your PHP 'include_path' to include the parent directory of ".
	"libphutil/.");
	}

	phutil_load_library('arcanist/src');

	// Load Phabricator itself using the absolute path, so we never end up doing
	// anything surprising (loading index.php and libraries from different
	// directories).
	phutil_load_library($phabricator_root.'/src');
	}

	/* -( Output Capture )----------------------------------------------------- */


	public static function beginOutputCapture() {
	if (self::$capturingOutput) {
	self::didFatal("Already capturing output!");
	}
	self::$capturingOutput = true;
	ob_start();
	}


	public static function endOutputCapture() {
	if (!self::$capturingOutput) {
	return null;
	}
	self::$capturingOutput = false;
	return ob_get_clean();
	}


	/* -( In Case of Apocalypse )---------------------------------------------- */


	/**
	* @task apocalypse
	*/
	public static function didFatal($message) {
	self::endOutputCapture();
	$access_log = self::getGlobal('log.access');

	if ($access_log) {
	// We may end up here before the access log is initialized, e.g. from
	// verifyPHP().
	$access_log->setData(
	array(
	'c' => 500,
	));
	$access_log->write();
	}

	header(
	'Content-Type: text/plain; charset=utf-8',
	$replace = true,
	$http_error = 500);

	error_log($message);
	echo $message;

	exit(1);
	}


	/* -( Validation )--------------------------------------------------------- */


	/**
	* @task validation
	*/
	private static function setupPHP() {
	error_reporting(E_ALL \| E_STRICT);
	ini_set('memory_limit', -1);
	}

	/**
	* @task validation
	*/
	private static function normalizeInput() {
	// Replace superglobals with unfiltered versions, disrespect php.ini (we
	// filter ourselves)
	$filter = array(INPUT_GET, INPUT_POST,
	INPUT_SERVER, INPUT_ENV, INPUT_COOKIE);
	foreach ($filter as $type) {
	$filtered = filter_input_array($type, FILTER_UNSAFE_RAW);
	if (!is_array($filtered)) {
	continue;
	}
	switch ($type) {
	case INPUT_SERVER:
	$_SERVER = array_merge($_SERVER, $filtered);
	break;
	case INPUT_GET:
	$_GET = array_merge($_GET, $filtered);
	break;
	case INPUT_COOKIE:
	$_COOKIE = array_merge($_COOKIE, $filtered);
	break;
	case INPUT_POST:
	$_POST = array_merge($_POST, $filtered);
	break;
	case INPUT_ENV;
	$_ENV = array_merge($_ENV, $filtered);
	break;
	}
	}

	// rebuild $_REQUEST, respecting order declared in ini files
	$order = ini_get('request_order');
	if (!$order) {
	$order = ini_get('variables_order');
	}
	if (!$order) {
	// $_REQUEST will be empty, leave it alone
	return;
	}
	$_REQUEST = array();
	for ($i = 0; $i < strlen($order); $i++) {
	switch ($order[$i]) {
	case 'G':
	$_REQUEST = array_merge($_REQUEST, $_GET);
	break;
	case 'P':
	$_REQUEST = array_merge($_REQUEST, $_POST);
	break;
	case 'C':
	$_REQUEST = array_merge($_REQUEST, $_COOKIE);
	break;
	default:
	// $_ENV and $_SERVER never go into $_REQUEST
	break;
	}
	}
	}

	/**
	* @task validation
	*/
	private static function verifyPHP() {
	$required_version = '5.2.3';
	if (version_compare(PHP_VERSION, $required_version) < 0) {
	self::didFatal(
	"You are running PHP version '".PHP_VERSION."', which is older than ".
	"the minimum version, '{$required_version}'. Update to at least ".
	"'{$required_version}'.");
	}

	if (get_magic_quotes_gpc()) {
	self::didFatal(
	"Your server is configured with PHP 'magic_quotes_gpc' enabled. This ".
	"feature is 'highly discouraged' by PHP's developers and you must ".
	"disable it to run Phabricator. Consult the PHP manual for ".
	"instructions.");
	}

	if (extension_loaded('apc')) {
	$apc_version = phpversion('apc');
	$known_bad = array(
	'3.1.14' => true,
	'3.1.15' => true,
	'3.1.15-dev' => true,
	);
	if (isset($known_bad[$apc_version])) {
	self::didFatal(
	"You have APC {$apc_version} installed. This version of APC is ".
	"known to be bad, and does not work with Phabricator (it will ".
	"cause Phabricator to fatal unrecoverably with nonsense errors). ".
	"Downgrade to version 3.1.13.");
	}
	}
	}


	/**
	* @task validation
	*/
	private static function verifyRewriteRules() {
	if (isset($_REQUEST['__path__']) && strlen($_REQUEST['__path__'])) {
	return;
	}

	if (php_sapi_name() == 'cli-server') {
	// Compatibility with PHP 5.4+ built-in web server.
	$url = parse_url($_SERVER['REQUEST_URI']);
	$_REQUEST['__path__'] = $url['path'];
	return;
	}

	if (!isset($_REQUEST['__path__'])) {
	self::didFatal(
	"Request parameter '__path__' is not set. Your rewrite rules ".
	"are not configured correctly.");
	}

	if (!strlen($_REQUEST['__path__'])) {
	self::didFatal(
	"Request parameter '__path__' is set, but empty. Your rewrite rules ".
	"are not configured correctly. The '__path__' should always ".
	"begin with a '/'.");
	}
	}


	/**
	* @task validation
	*/
	private static function validateGlobal($key) {
	static $globals = array(
	'log.access' => true,
	+ 'csrf.salt' => true,
	);

	if (empty($globals[$key])) {
	throw new Exception("Access to unknown startup global '{$key}'!");
	}
	}


	/**
	* Detect if this request has had its POST data stripped by exceeding the
	* 'post_max_size' PHP configuration limit.
	*
	* PHP has a setting called 'post_max_size'. If a POST request arrives with
	* a body larger than the limit, PHP doesn't generate $_POST but processes
	* the request anyway, and provides no formal way to detect that this
	* happened.
	*
	* We can still read the entire body out of `php://input`. However according
	* to the documentation the stream isn't available for "multipart/form-data"
	* (on nginx + php-fpm it appears that it is available, though, at least) so
	* any attempt to generate $_POST would be fragile.
	*
	* @task validation
	*/
	private static function detectPostMaxSizeTriggered() {
	// If this wasn't a POST, we're fine.
	if ($_SERVER['REQUEST_METHOD'] != 'POST') {
	return;
	}

	// If there's POST data, clearly we're in good shape.
	if ($_POST) {
	return;
	}

	// For HTML5 drag-and-drop file uploads, Safari submits the data as
	// "application/x-www-form-urlencoded". For most files this generates
	// something in POST because most files decode to some nonempty (albeit
	// meaningless) value. However, some files (particularly small images)
	// don't decode to anything. If we know this is a drag-and-drop upload,
	// we can skip this check.
	if (isset($_REQUEST['__upload__'])) {
	return;
	}

	// PHP generates $_POST only for two content types. This routing happens
	// in `main/php_content_types.c` in PHP. Normally, all forms use one of
	// these content types, but some requests may not -- for example, Firefox
	// submits files sent over HTML5 XMLHTTPRequest APIs with the Content-Type
	// of the file itself. If we don't have a recognized content type, we
	// don't need $_POST.
	//
	// NOTE: We use strncmp() because the actual content type may be something
	// like "multipart/form-data; boundary=...".
	//
	// NOTE: Chrome sometimes omits this header, see some discussion in T1762
	// and http://code.google.com/p/chromium/issues/detail?id=6800
	$content_type = isset($_SERVER['CONTENT_TYPE'])
	? $_SERVER['CONTENT_TYPE']
	: '';

	$parsed_types = array(
	'application/x-www-form-urlencoded',
	'multipart/form-data',
	);

	$is_parsed_type = false;
	foreach ($parsed_types as $parsed_type) {
	if (strncmp($content_type, $parsed_type, strlen($parsed_type)) === 0) {
	$is_parsed_type = true;
	break;
	}
	}

	if (!$is_parsed_type) {
	return;
	}

	// Check for 'Content-Length'. If there's no data, we don't expect $_POST
	// to exist.
	$length = (int)$_SERVER['CONTENT_LENGTH'];
	if (!$length) {
	return;
	}

	// Time to fatal: we know this was a POST with data that should have been
	// populated into $_POST, but it wasn't.

	$config = ini_get('post_max_size');
	PhabricatorStartup::didFatal(
	"As received by the server, this request had a nonzero content length ".
	"but no POST data.\n\n".
	"Normally, this indicates that it exceeds the 'post_max_size' setting ".
	"in the PHP configuration on the server. Increase the 'post_max_size' ".
	"setting or reduce the size of the request.\n\n".
	"Request size according to 'Content-Length' was '{$length}', ".
	"'post_max_size' is set to '{$config}'.");
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Mar 17, 1:25 AM (12 h, 11 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 964089
Default Alt Text: (41 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions