PHP SimpleSAML_Configuration::getString方法代码示例

 /**
  * Constructor
  *
  * @param \SimpleSAML_Configuration $configuration Configuration object
  */
 public function __construct(\SimpleSAML_Configuration $configuration)
 {
     $this->configuration = $configuration;
     $this->localeDir = $this->configuration->resolvePath('locales');
     $this->language = new Language($configuration);
     $this->langcode = $this->language->getPosixLanguage($this->language->getLanguage());
     $this->i18nBackend = $this->configuration->getString('language.i18n.backend', self::SSP_I18N_BACKEND);
     $this->setupL10N();
 }

 /**
  * Check that the user has access to the statistics.
  *
  * If the user doesn't have access, send the user to the login page.
  */
 public static function checkAccess(SimpleSAML_Configuration $statconfig)
 {
     $protected = $statconfig->getBoolean('protected', FALSE);
     $authsource = $statconfig->getString('auth', NULL);
     $allowedusers = $statconfig->getValue('allowedUsers', NULL);
     $useridattr = $statconfig->getString('useridattr', 'eduPersonPrincipalName');
     $acl = $statconfig->getValue('acl', NULL);
     if ($acl !== NULL && !is_string($acl) && !is_array($acl)) {
         throw new SimpleSAML_Error_Exception('Invalid value for \'acl\'-option. Should be an array or a string.');
     }
     if (!$protected) {
         return;
     }
     if (SimpleSAML\Utils\Auth::isAdmin()) {
         // User logged in as admin. OK.
         SimpleSAML_Logger::debug('Statistics auth - logged in as admin, access granted');
         return;
     }
     if (!isset($authsource)) {
         // If authsource is not defined, init admin login.
         SimpleSAML\Utils\Auth::requireAdmin();
     }
     /* We are using an authsource for login. */
     $as = new SimpleSAML_Auth_Simple($authsource);
     $as->requireAuth();
     // User logged in with auth source.
     SimpleSAML_Logger::debug('Statistics auth - valid login with auth source [' . $authsource . ']');
     // Retrieving attributes
     $attributes = $as->getAttributes();
     if (!empty($allowedusers)) {
         // Check if userid exists
         if (!isset($attributes[$useridattr][0])) {
             throw new Exception('User ID is missing');
         }
         // Check if userid is allowed access..
         if (in_array($attributes[$useridattr][0], $allowedusers)) {
             SimpleSAML_Logger::debug('Statistics auth - User granted access by user ID [' . $attributes[$useridattr][0] . ']');
             return;
         }
         SimpleSAML_Logger::debug('Statistics auth - User denied access by user ID [' . $attributes[$useridattr][0] . ']');
     } else {
         SimpleSAML_Logger::debug('Statistics auth - no allowedUsers list.');
     }
     if (!is_null($acl)) {
         $acl = new sspmod_core_ACL($acl);
         if ($acl->allows($attributes)) {
             SimpleSAML_Logger::debug('Statistics auth - allowed access by ACL.');
             return;
         }
         SimpleSAML_Logger::debug('Statistics auth - denied access by ACL.');
     } else {
         SimpleSAML_Logger::debug('Statistics auth - no ACL configured.');
     }
     throw new SimpleSAML_Error_Exception('Access denied to the current user.');
 }

 /**
  * Initializes this discovery service.
  *
  * The constructor does the parsing of the request. If this is an invalid request, it will throw an exception.
  *
  * @param array  $metadataSets Array with metadata sets we find remote entities in.
  * @param string $instance The name of this instance of the discovery service.
  */
 public function __construct(array $metadataSets, $instance)
 {
     parent::__construct($metadataSets, $instance);
     $this->discoconfig = SimpleSAML_Configuration::getConfig('module_discopower.php');
     $this->cdcDomain = $this->discoconfig->getString('cdc.domain', null);
     if ($this->cdcDomain !== null && $this->cdcDomain[0] !== '.') {
         // ensure that the CDC domain starts with a dot ('.') as required by the spec
         $this->cdcDomain = '.' . $this->cdcDomain;
     }
     $this->cdcLifetime = $this->discoconfig->getInteger('cdc.lifetime', null);
 }

 /**
  * Constructor
  *
  * @param \SimpleSAML_Configuration $configuration Configuration object
  */
 public function __construct(\SimpleSAML_Configuration $configuration)
 {
     $this->configuration = $configuration;
     $this->availableLanguages = $this->configuration->getArray('language.available', array('en'));
     $this->defaultLanguage = $this->configuration->getString('language.default', 'en');
     $this->languageParameterName = $this->configuration->getString('language.parameter.name', 'language');
     $this->customFunction = $this->configuration->getArray('language.get_language_function', null);
     $this->rtlLanguages = $this->configuration->getArray('language.rtl', array());
     if (isset($_GET[$this->languageParameterName])) {
         $this->setLanguage($_GET[$this->languageParameterName], $this->configuration->getBoolean('language.parameter.setcookie', true));
     }
 }

 /**
  * Initialize this EntitySource.
  *
  * @param SimpleSAML_Configuration $config  The configuration.
  */
 public function __construct(sspmod_aggregator2_Aggregator $aggregator, SimpleSAML_Configuration $config)
 {
     $this->logLoc = 'aggregator2:' . $aggregator->getId() . ': ';
     $this->aggregator = $aggregator;
     $this->url = $config->getString('url');
     $this->sslCAFile = $config->getString('ssl.cafile', NULL);
     if ($this->sslCAFile === NULL) {
         $this->sslCAFile = $aggregator->getCAFile();
     }
     $this->certificate = $config->getString('cert', NULL);
     $this->cacheId = sha1($this->url);
     $this->cacheTag = sha1(serialize($config));
 }

 private static function enrichForDecryptionProvider(SimpleSAML_Configuration $configuration, array &$baseConfiguration)
 {
     if ($configuration->has('sharedKey')) {
         $baseConfiguration['sharedKey'] = $configuration->getString('sharedKey', NULL);
     }
     if ($configuration->has('new_privatekey')) {
         $baseConfiguration['privateKeys'][] = new SAML2_Configuration_PrivateKey($configuration->getString('new_privatekey'), SAML2_Configuration_PrivateKey::NAME_NEW, $configuration->getString('new_privatekey_pass', NULL));
     }
     if ($configuration->getBoolean('assertion.encryption', FALSE)) {
         $baseConfiguration['privateKeys'][] = new SAML2_Configuration_PrivateKey($configuration->getString('privatekey'), SAML2_Configuration_PrivateKey::NAME_DEFAULT, $configuration->getString('privatekey_pass', NULL));
         if ($configuration->has('encryption.blacklisted-algorithms')) {
             $baseConfiguration['blacklistedEncryptionAlgorithms'] = $configuration->get('encryption.blacklisted-algorithms');
         }
     }
 }

 /**
  * Build a new logging handler based on files.
  */
 public function __construct(\SimpleSAML_Configuration $config)
 {
     // get the metadata handler option from the configuration
     $this->logFile = $config->getPathValue('loggingdir', 'log/') . $config->getString('logging.logfile', 'simplesamlphp.log');
     $this->processname = $config->getString('logging.processname', 'SimpleSAMLphp');
     if (@file_exists($this->logFile)) {
         if (!@is_writeable($this->logFile)) {
             throw new \Exception("Could not write to logfile: " . $this->logFile);
         }
     } else {
         if (!@touch($this->logFile)) {
             throw new \Exception("Could not create logfile: " . $this->logFile . " The logging directory is not writable for the web server user.");
         }
     }
     \SimpleSAML\Utils\Time::initTimezone();
 }

 /**
  * Subscribe to an address
  *
  * @param int    $uid          Uid of user
  * @param string $subscription The address to subscribe
  * @param string $type         Type of subscription
  *
  * @return bool Return true on success and false on error
  */
 public function subscribe($uid, $subscription, $type = null)
 {
     if (is_null($type)) {
         $type = $this->_config->getString('messenger.default', 'INBOX');
     }
     // Check if subscription already exists
     $st = self::execute('SELECT * 
          FROM `' . self::$prefix . 'subscription`
          WHERE `uid` = ? AND `subscription` = ?', array($uid, $subscription));
     if ($st === false) {
         return false;
     }
     if ($st->rowCount() > 0) {
         return false;
     }
     // Insert new subscription
     $st = self::execute('INSERT INTO `' . self::$prefix . 'subscription` 
         (`uid`, `subscription`, `type`, `created`, `ip`) 
         VALUES
         (?, ?, ?, ?, ?);', array($uid, $subscription, $type, date('c'), $_SERVER['REMOTE_ADDR']));
     if ($st === false) {
         SimpleSAML_Logger::error('JANUS: Error fetching all entities');
         return false;
     }
     return self::$db->lastInsertId();
 }

 /**
  * Create an output from a configuration object.
  *
  * @param SimpleSAML_Configuration $config  The configuration object.
  * @return
  */
 private static function createOutput(SimpleSAML_Configuration $config)
 {
     $cls = $config->getString('class');
     $cls = SimpleSAML_Module::resolveClass($cls, 'Stats_Output', 'SimpleSAML_Stats_Output');
     $output = new $cls($config);
     return $output;
 }

 /**
  * Initialize the output.
  *
  * @param SimpleSAML_Configuration $config  The configuration for this output.
  */
 public function __construct(SimpleSAML_Configuration $config)
 {
     $logLevel = $config->getString('level', 'notice');
     $this->logger = array('SimpleSAML_Logger', $logLevel);
     if (!is_callable($this->logger)) {
         throw new Exception('Invalid log level: ' . var_export($logLevel, TRUE));
     }
 }

 /**
  * Create new entity with parsed entityid
  *
  * Create a new entity and give the user access to the entity.
  *
  * @param string $entityid Entity id for the new entity
  * @param string $type     Entity type
  *
  * @return sspmod_janus_Entity|bool Returns the entity or false on error.
  * @since Method available since Release 1.0.0
  */
 public function createNewEntity($entityid, $type)
 {
     assert('is_string($entityid)');
     assert('is_string($type)');
     if ($this->isEntityIdInUse($entityid, $errorMessage)) {
         return $errorMessage;
     }
     if ($this->hasEntityIdBeenUsed($entityid, $errorMessage)) {
         return $errorMessage;
     }
     $startstate = $this->_config->getString('workflowstate.default');
     // Get the default ARP
     $default_arp = '0';
     $st = $this->execute("SELECT aid FROM " . self::$prefix . "arp WHERE is_default = TRUE AND deleted = ''");
     if ($st) {
         $rows = $st->fetchAll();
         if (count($rows) === 1) {
             $default_arp = $rows[0]['aid'];
         }
     }
     // Instantiate a new entity
     $entity = new sspmod_janus_Entity($this->_config, true);
     $entity->setEntityid($entityid);
     $entity->setWorkflow($startstate);
     $entity->setType($type);
     $entity->setArp($default_arp);
     $entity->setUser($this->_user->getUid());
     $entity->setRevisionnote('Entity created.');
     $entity->save();
     $st = $this->execute('INSERT INTO ' . self::$prefix . 'hasEntity 
         (`uid`, `eid`, `created`, `ip`) 
         VALUES 
         (?, ?, ?, ?);', array($this->_user->getUid(), $entity->getEid(), date('c'), $_SERVER['REMOTE_ADDR']));
     if ($st === false) {
         return 'error_db';
     }
     $ec = new sspmod_janus_EntityController($this->_config);
     $ec->setEntity($entity);
     $update = false;
     // Get metadatafields for new type
     $nm_mb = new sspmod_janus_MetadatafieldBuilder($this->_config->getArray('metadatafields.' . $type));
     $metadatafields = $nm_mb->getMetadatafields();
     // Add all required fileds
     foreach ($metadatafields as $mf) {
         if (isset($mf->required) && $mf->required === true) {
             $ec->addMetadata($mf->name, $mf->default);
             $update = true;
         }
     }
     if ($update === true) {
         $ec->saveEntity();
     }
     // Reset list of entities
     $this->_entities = null;
     $this->_loadEntities();
     return $entity->getEid();
 }

 /**
  * Build a new logging handler based on syslog.
  */
 public function __construct(\SimpleSAML_Configuration $config)
 {
     $facility = $config->getInteger('logging.facility', defined('LOG_LOCAL5') ? constant('LOG_LOCAL5') : LOG_USER);
     $processname = $config->getString('logging.processname', 'SimpleSAMLphp');
     // Setting facility to LOG_USER (only valid in Windows), enable log level rewrite on windows systems
     if (System::getOS() === System::WINDOWS) {
         $this->isWindows = true;
         $facility = LOG_USER;
     }
     openlog($processname, LOG_PID, $facility);
 }

 /**
  * Receive a SAML 2 message sent using the HTTP-Artifact binding.
  *
  * Throws an exception if it is unable receive the message.
  *
  * @return SAML2_Message The received message.
  * @throws Exception
  */
 public function receive()
 {
     if (array_key_exists('SAMLart', $_REQUEST)) {
         $artifact = base64_decode($_REQUEST['SAMLart']);
         $endpointIndex = bin2hex(substr($artifact, 2, 2));
         $sourceId = bin2hex(substr($artifact, 4, 20));
     } else {
         throw new Exception('Missing SAMLArt parameter.');
     }
     $metadataHandler = SimpleSAML_Metadata_MetaDataStorageHandler::getMetadataHandler();
     $idpMetadata = $metadataHandler->getMetaDataConfigForSha1($sourceId, 'saml20-idp-remote');
     if ($idpMetadata === NULL) {
         throw new Exception('No metadata found for remote provider with SHA1 ID: ' . var_export($sourceId, TRUE));
     }
     $endpoint = NULL;
     foreach ($idpMetadata->getEndpoints('ArtifactResolutionService') as $ep) {
         if ($ep['index'] === hexdec($endpointIndex)) {
             $endpoint = $ep;
             break;
         }
     }
     if ($endpoint === NULL) {
         throw new Exception('No ArtifactResolutionService with the correct index.');
     }
     SAML2_Utils::getContainer()->getLogger()->debug("ArtifactResolutionService endpoint being used is := " . $endpoint['Location']);
     //Construct the ArtifactResolve Request
     $ar = new SAML2_ArtifactResolve();
     /* Set the request attributes */
     $ar->setIssuer($this->spMetadata->getString('entityid'));
     $ar->setArtifact($_REQUEST['SAMLart']);
     $ar->setDestination($endpoint['Location']);
     require_once realpath(__DIR__ . '/../../../simplesamlphp/modules/saml/lib/Message.php');
     /* Sign the request */
     sspmod_saml_Message::addSign($this->spMetadata, $idpMetadata, $ar);
     // Shoaib - moved from the SOAPClient.
     $soap = new SAML2_SOAPClient();
     // Send message through SoapClient
     /** @var SAML2_ArtifactResponse $artifactResponse */
     $artifactResponse = $soap->send($ar, $this->spMetadata);
     if (!$artifactResponse->isSuccess()) {
         return false;
     }
     $xml = $artifactResponse->getAny();
     if ($xml === NULL) {
         /* Empty ArtifactResponse - possibly because of Artifact replay? */
         return NULL;
     }
     $samlResponse = SAML2_Message::fromXML($xml);
     $samlResponse->addValidator(array(get_class($this), 'validateSignature'), $artifactResponse);
     if (isset($_REQUEST['RelayState'])) {
         $samlResponse->setRelayState($_REQUEST['RelayState']);
     }
     return $samlResponse;
 }

 /**
  * Initialize an IdP.
  *
  * @param string $id  The identifier of this IdP.
  */
 private function __construct($id)
 {
     assert('is_string($id)');
     $this->id = $id;
     $metadata = SimpleSAML_Metadata_MetaDataStorageHandler::getMetadataHandler();
     $globalConfig = SimpleSAML_Configuration::getInstance();
     if (substr($id, 0, 6) === 'saml2:') {
         if (!$globalConfig->getBoolean('enable.saml20-idp', FALSE)) {
             throw new SimpleSAML_Error_Exception('enable.saml20-idp disabled in config.php.');
         }
         $this->config = $metadata->getMetaDataConfig(substr($id, 6), 'saml20-idp-hosted');
     } elseif (substr($id, 0, 6) === 'saml1:') {
         if (!$globalConfig->getBoolean('enable.shib13-idp', FALSE)) {
             throw new SimpleSAML_Error_Exception('enable.shib13-idp disabled in config.php.');
         }
         $this->config = $metadata->getMetaDataConfig(substr($id, 6), 'shib13-idp-hosted');
     } elseif (substr($id, 0, 5) === 'adfs:') {
         if (!$globalConfig->getBoolean('enable.adfs-idp', FALSE)) {
             throw new SimpleSAML_Error_Exception('enable.adfs-idp disabled in config.php.');
         }
         $this->config = $metadata->getMetaDataConfig(substr($id, 5), 'adfs-idp-hosted');
         try {
             /* This makes the ADFS IdP use the same SP associations as the SAML 2.0 IdP. */
             $saml2EntityId = $metadata->getMetaDataCurrentEntityID('saml20-idp-hosted');
             $this->associationGroup = 'saml2:' . $saml2EntityId;
         } catch (Exception $e) {
             /* Probably no SAML 2 IdP configured for this host. Ignore the error. */
         }
     } else {
         assert(FALSE);
     }
     if ($this->associationGroup === NULL) {
         $this->associationGroup = $this->id;
     }
     $auth = $this->config->getString('auth');
     if (SimpleSAML_Auth_Source::getById($auth) !== NULL) {
         $this->authSource = new SimpleSAML_Auth_Simple($auth);
     } else {
         $this->authSource = new SimpleSAML_Auth_BWC($auth, $this->config->getString('authority', NULL));
     }
 }

 /**
  * This functions finds what key & certificate files should be used to sign the metadata
  * for the given entity.
  *
  * @param SimpleSAML_Configuration $config Our SimpleSAML_Configuration instance.
  * @param array                    $entityMetadata The metadata of the entity.
  * @param string                   $type A string which describes the type entity this is, e.g. 'SAML 2 IdP' or
  *     'Shib 1.3 SP'.
  *
  * @return array An associative array with the keys 'privatekey', 'certificate', and optionally 'privatekey_pass'.
  * @throws Exception If the key and certificate used to sign is unknown.
  */
 private static function findKeyCert($config, $entityMetadata, $type)
 {
     // first we look for metadata.privatekey and metadata.certificate in the metadata
     if (array_key_exists('metadata.sign.privatekey', $entityMetadata) || array_key_exists('metadata.sign.certificate', $entityMetadata)) {
         if (!array_key_exists('metadata.sign.privatekey', $entityMetadata) || !array_key_exists('metadata.sign.certificate', $entityMetadata)) {
             throw new Exception('Missing either the "metadata.sign.privatekey" or the' . ' "metadata.sign.certificate" configuration option in the metadata for' . ' the ' . $type . ' "' . $entityMetadata['entityid'] . '". If one of' . ' these options is specified, then the other must also be specified.');
         }
         $ret = array('privatekey' => $entityMetadata['metadata.sign.privatekey'], 'certificate' => $entityMetadata['metadata.sign.certificate']);
         if (array_key_exists('metadata.sign.privatekey_pass', $entityMetadata)) {
             $ret['privatekey_pass'] = $entityMetadata['metadata.sign.privatekey_pass'];
         }
         return $ret;
     }
     // then we look for default values in the global configuration
     $privatekey = $config->getString('metadata.sign.privatekey', null);
     $certificate = $config->getString('metadata.sign.certificate', null);
     if ($privatekey !== null || $certificate !== null) {
         if ($privatekey === null || $certificate === null) {
             throw new Exception('Missing either the "metadata.sign.privatekey" or the' . ' "metadata.sign.certificate" configuration option in the global' . ' configuration. If one of these options is specified, then the other' . ' must also be specified.');
         }
         $ret = array('privatekey' => $privatekey, 'certificate' => $certificate);
         $privatekey_pass = $config->getString('metadata.sign.privatekey_pass', null);
         if ($privatekey_pass !== null) {
             $ret['privatekey_pass'] = $privatekey_pass;
         }
         return $ret;
     }
     // as a last resort we attempt to use the privatekey and certificate option from the metadata
     if (array_key_exists('privatekey', $entityMetadata) || array_key_exists('certificate', $entityMetadata)) {
         if (!array_key_exists('privatekey', $entityMetadata) || !array_key_exists('certificate', $entityMetadata)) {
             throw new Exception('Both the "privatekey" and the "certificate" option must' . ' be set in the metadata for the ' . $type . ' "' . $entityMetadata['entityid'] . '" before it is possible to sign metadata' . ' from this entity.');
         }
         $ret = array('privatekey' => $entityMetadata['privatekey'], 'certificate' => $entityMetadata['certificate']);
         if (array_key_exists('privatekey_pass', $entityMetadata)) {
             $ret['privatekey_pass'] = $entityMetadata['privatekey_pass'];
         }
         return $ret;
     }
     throw new Exception('Could not find what key & certificate should be used to sign the metadata' . ' for the ' . $type . ' "' . $entityMetadata['entityid'] . '".');
 }