Update positioning in contact page
[living-lab-site.git] / application / libraries / Auth / OpenID / TrustRoot.php
1 <?php
2 /**
3  * Functions for dealing with OpenID trust roots
4  *
5  * PHP versions 4 and 5
6  *
7  * LICENSE: See the COPYING file included in this distribution.
8  *
9  * @package OpenID
10  * @author JanRain, Inc. <openid@janrain.com>
11  * @copyright 2005-2008 Janrain, Inc.
12  * @license http://www.apache.org/licenses/LICENSE-2.0 Apache
13  */
14
15 require_once 'Auth/OpenID/Discover.php';
16
17 /**
18  * A regular expression that matches a domain ending in a top-level domains.
19  * Used in checking trust roots for sanity.
20  *
21  * @access private
22  */
23 define('Auth_OpenID___TLDs',
24        '/\.(ac|ad|ae|aero|af|ag|ai|al|am|an|ao|aq|ar|arpa|as|asia' .
25        '|at|au|aw|ax|az|ba|bb|bd|be|bf|bg|bh|bi|biz|bj|bm|bn|bo|br' .
26        '|bs|bt|bv|bw|by|bz|ca|cat|cc|cd|cf|cg|ch|ci|ck|cl|cm|cn|co' .
27        '|com|coop|cr|cu|cv|cx|cy|cz|de|dj|dk|dm|do|dz|ec|edu|ee|eg' .
28        '|er|es|et|eu|fi|fj|fk|fm|fo|fr|ga|gb|gd|ge|gf|gg|gh|gi|gl' .
29        '|gm|gn|gov|gp|gq|gr|gs|gt|gu|gw|gy|hk|hm|hn|hr|ht|hu|id|ie' .
30        '|il|im|in|info|int|io|iq|ir|is|it|je|jm|jo|jobs|jp|ke|kg|kh' .
31        '|ki|km|kn|kp|kr|kw|ky|kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly' .
32        '|ma|mc|md|me|mg|mh|mil|mk|ml|mm|mn|mo|mobi|mp|mq|mr|ms|mt' .
33        '|mu|museum|mv|mw|mx|my|mz|na|name|nc|ne|net|nf|ng|ni|nl|no' .
34        '|np|nr|nu|nz|om|org|pa|pe|pf|pg|ph|pk|pl|pm|pn|pr|pro|ps|pt' .
35        '|pw|py|qa|re|ro|rs|ru|rw|sa|sb|sc|sd|se|sg|sh|si|sj|sk|sl' .
36        '|sm|sn|so|sr|st|su|sv|sy|sz|tc|td|tel|tf|tg|th|tj|tk|tl|tm' .
37        '|tn|to|tp|tr|travel|tt|tv|tw|tz|ua|ug|uk|us|uy|uz|va|vc|ve' .
38        '|vg|vi|vn|vu|wf|ws|xn--0zwm56d|xn--11b5bs3a9aj6g' .
39        '|xn--80akhbyknj4f|xn--9t4b11yi5a|xn--deba0ad|xn--g6w251d' .
40        '|xn--hgbk6aj7f53bba|xn--hlcj6aya9esc7a|xn--jxalpdlp' .
41        '|xn--kgbechtv|xn--zckzah|ye|yt|yu|za|zm|zw)\.?$/');
42
43 define('Auth_OpenID___HostSegmentRe',
44        "/^(?:[-a-zA-Z0-9!$&'\\(\\)\\*+,;=._~]|%[a-zA-Z0-9]{2})*$/");
45
46 /**
47  * A wrapper for trust-root related functions
48  */
49 class Auth_OpenID_TrustRoot {
50     /*
51      * Return a discovery URL for this realm.
52      *
53      * Return null if the realm could not be parsed or was not valid.
54      *
55      * @param return_to The relying party return URL of the OpenID
56      * authentication request
57      *
58      * @return The URL upon which relying party discovery should be
59      * run in order to verify the return_to URL
60      */
61     static function buildDiscoveryURL($realm)
62     {
63         $parsed = Auth_OpenID_TrustRoot::_parse($realm);
64
65         if ($parsed === false) {
66             return false;
67         }
68
69         if ($parsed['wildcard']) {
70             // Use "www." in place of the star
71             if ($parsed['host'][0] != '.') {
72                 return false;
73             }
74
75             $www_domain = 'www' . $parsed['host'];
76
77             return sprintf('%s://%s%s', $parsed['scheme'],
78                            $www_domain, $parsed['path']);
79         } else {
80             return $parsed['unparsed'];
81         }
82     }
83
84     /**
85      * Parse a URL into its trust_root parts.
86      *
87      * @static
88      *
89      * @access private
90      *
91      * @param string $trust_root The url to parse
92      *
93      * @return mixed $parsed Either an associative array of trust root
94      * parts or false if parsing failed.
95      */
96     static function _parse($trust_root)
97     {
98         $trust_root = Auth_OpenID_urinorm($trust_root);
99         if ($trust_root === null) {
100             return false;
101         }
102
103         if (preg_match("/:\/\/[^:]+(:\d+){2,}(\/|$)/", $trust_root)) {
104             return false;
105         }
106
107         $parts = @parse_url($trust_root);
108         if ($parts === false) {
109             return false;
110         }
111
112         $required_parts = array('scheme', 'host');
113         $forbidden_parts = array('user', 'pass', 'fragment');
114         $keys = array_keys($parts);
115         if (array_intersect($keys, $required_parts) != $required_parts) {
116             return false;
117         }
118
119         if (array_intersect($keys, $forbidden_parts) != array()) {
120             return false;
121         }
122
123         if (!preg_match(Auth_OpenID___HostSegmentRe, $parts['host'])) {
124             return false;
125         }
126
127         $scheme = strtolower($parts['scheme']);
128         $allowed_schemes = array('http', 'https');
129         if (!in_array($scheme, $allowed_schemes)) {
130             return false;
131         }
132         $parts['scheme'] = $scheme;
133
134         $host = strtolower($parts['host']);
135         $hostparts = explode('*', $host);
136         switch (count($hostparts)) {
137         case 1:
138             $parts['wildcard'] = false;
139             break;
140         case 2:
141             if ($hostparts[0] ||
142                 ($hostparts[1] && substr($hostparts[1], 0, 1) != '.')) {
143                 return false;
144             }
145             $host = $hostparts[1];
146             $parts['wildcard'] = true;
147             break;
148         default:
149             return false;
150         }
151         if (strpos($host, ':') !== false) {
152             return false;
153         }
154
155         $parts['host'] = $host;
156
157         if (isset($parts['path'])) {
158             $path = strtolower($parts['path']);
159             if (substr($path, 0, 1) != '/') {
160                 return false;
161             }
162         } else {
163             $path = '/';
164         }
165
166         $parts['path'] = $path;
167         if (!isset($parts['port'])) {
168             $parts['port'] = false;
169         }
170
171
172         $parts['unparsed'] = $trust_root;
173
174         return $parts;
175     }
176
177     /**
178      * Is this trust root sane?
179      *
180      * A trust root is sane if it is syntactically valid and it has a
181      * reasonable domain name. Specifically, the domain name must be
182      * more than one level below a standard TLD or more than two
183      * levels below a two-letter tld.
184      *
185      * For example, '*.com' is not a sane trust root, but '*.foo.com'
186      * is.  '*.co.uk' is not sane, but '*.bbc.co.uk' is.
187      *
188      * This check is not always correct, but it attempts to err on the
189      * side of marking sane trust roots insane instead of marking
190      * insane trust roots sane. For example, 'kink.fm' is marked as
191      * insane even though it "should" (for some meaning of should) be
192      * marked sane.
193      *
194      * This function should be used when creating OpenID servers to
195      * alert the users of the server when a consumer attempts to get
196      * the user to accept a suspicious trust root.
197      *
198      * @static
199      * @param string $trust_root The trust root to check
200      * @return bool $sanity Whether the trust root looks OK
201      */
202     static function isSane($trust_root)
203     {
204         $parts = Auth_OpenID_TrustRoot::_parse($trust_root);
205         if ($parts === false) {
206             return false;
207         }
208
209         // Localhost is a special case
210         if ($parts['host'] == 'localhost') {
211             return true;
212         }
213         
214         $host_parts = explode('.', $parts['host']);
215         if ($parts['wildcard']) {
216             // Remove the empty string from the beginning of the array
217             array_shift($host_parts);
218         }
219
220         if ($host_parts && !$host_parts[count($host_parts) - 1]) {
221             array_pop($host_parts);
222         }
223
224         if (!$host_parts) {
225             return false;
226         }
227
228         // Don't allow adjacent dots
229         if (in_array('', $host_parts, true)) {
230             return false;
231         }
232
233         // Get the top-level domain of the host. If it is not a valid TLD,
234         // it's not sane.
235         preg_match(Auth_OpenID___TLDs, $parts['host'], $matches);
236         if (!$matches) {
237             return false;
238         }
239         $tld = $matches[1];
240
241         if (count($host_parts) == 1) {
242             return false;
243         }
244
245         if ($parts['wildcard']) {
246             // It's a 2-letter tld with a short second to last segment
247             // so there needs to be more than two segments specified
248             // (e.g. *.co.uk is insane)
249             $second_level = $host_parts[count($host_parts) - 2];
250             if (strlen($tld) == 2 && strlen($second_level) <= 3) {
251                 return count($host_parts) > 2;
252             }
253         }
254
255         return true;
256     }
257
258     /**
259      * Does this URL match the given trust root?
260      *
261      * Return whether the URL falls under the given trust root. This
262      * does not check whether the trust root is sane. If the URL or
263      * trust root do not parse, this function will return false.
264      *
265      * @param string $trust_root The trust root to match against
266      *
267      * @param string $url The URL to check
268      *
269      * @return bool $matches Whether the URL matches against the
270      * trust root
271      */
272     static function match($trust_root, $url)
273     {
274         $trust_root_parsed = Auth_OpenID_TrustRoot::_parse($trust_root);
275         $url_parsed = Auth_OpenID_TrustRoot::_parse($url);
276         if (!$trust_root_parsed || !$url_parsed) {
277             return false;
278         }
279
280         // Check hosts matching
281         if ($url_parsed['wildcard']) {
282             return false;
283         }
284         if ($trust_root_parsed['wildcard']) {
285             $host_tail = $trust_root_parsed['host'];
286             $host = $url_parsed['host'];
287             if ($host_tail &&
288                 substr($host, -(strlen($host_tail))) != $host_tail &&
289                 substr($host_tail, 1) != $host) {
290                 return false;
291             }
292         } else {
293             if ($trust_root_parsed['host'] != $url_parsed['host']) {
294                 return false;
295             }
296         }
297
298         // Check path and query matching
299         $base_path = $trust_root_parsed['path'];
300         $path = $url_parsed['path'];
301         if (!isset($trust_root_parsed['query'])) {
302             if ($base_path != $path) {
303                 if (substr($path, 0, strlen($base_path)) != $base_path) {
304                     return false;
305                 }
306                 if (substr($base_path, strlen($base_path) - 1, 1) != '/' &&
307                     substr($path, strlen($base_path), 1) != '/') {
308                     return false;
309                 }
310             }
311         } else {
312             $base_query = $trust_root_parsed['query'];
313             $query = @$url_parsed['query'];
314             $qplus = substr($query, 0, strlen($base_query) + 1);
315             $bqplus = $base_query . '&';
316             if ($base_path != $path ||
317                 ($base_query != $query && $qplus != $bqplus)) {
318                 return false;
319             }
320         }
321
322         // The port and scheme need to match exactly
323         return ($trust_root_parsed['scheme'] == $url_parsed['scheme'] &&
324                 $url_parsed['port'] === $trust_root_parsed['port']);
325     }
326 }
327
328 /*
329  * If the endpoint is a relying party OpenID return_to endpoint,
330  * return the endpoint URL. Otherwise, return None.
331  *
332  * This function is intended to be used as a filter for the Yadis
333  * filtering interface.
334  *
335  * @see: C{L{openid.yadis.services}}
336  * @see: C{L{openid.yadis.filters}}
337  *
338  * @param endpoint: An XRDS BasicServiceEndpoint, as returned by
339  * performing Yadis dicovery.
340  *
341  * @returns: The endpoint URL or None if the endpoint is not a
342  * relying party endpoint.
343  */
344 function filter_extractReturnURL($endpoint)
345 {
346     if ($endpoint->matchTypes(array(Auth_OpenID_RP_RETURN_TO_URL_TYPE))) {
347         return $endpoint;
348     } else {
349         return null;
350     }
351 }
352
353 function &Auth_OpenID_extractReturnURL(&$endpoint_list)
354 {
355     $result = array();
356
357     foreach ($endpoint_list as $endpoint) {
358         if (filter_extractReturnURL($endpoint)) {
359             $result[] = $endpoint;
360         }
361     }
362
363     return $result;
364 }
365
366 /*
367  * Is the return_to URL under one of the supplied allowed return_to
368  * URLs?
369  */
370 function Auth_OpenID_returnToMatches($allowed_return_to_urls, $return_to)
371 {
372     foreach ($allowed_return_to_urls as $allowed_return_to) {
373         // A return_to pattern works the same as a realm, except that
374         // it's not allowed to use a wildcard. We'll model this by
375         // parsing it as a realm, and not trying to match it if it has
376         // a wildcard.
377
378         $return_realm = Auth_OpenID_TrustRoot::_parse($allowed_return_to);
379         if (// Parses as a trust root
380             ($return_realm !== false) &&
381             // Does not have a wildcard
382             (!$return_realm['wildcard']) &&
383             // Matches the return_to that we passed in with it
384             (Auth_OpenID_TrustRoot::match($allowed_return_to, $return_to))) {
385             return true;
386         }
387     }
388
389     // No URL in the list matched
390     return false;
391 }
392
393 /*
394  * Given a relying party discovery URL return a list of return_to
395  * URLs.
396  */
397 function Auth_OpenID_getAllowedReturnURLs($relying_party_url, $fetcher,
398               $discover_function=null)
399 {
400     if ($discover_function === null) {
401         $discover_function = array('Auth_Yadis_Yadis', 'discover');
402     }
403
404     $xrds_parse_cb = array('Auth_OpenID_ServiceEndpoint', 'consumerFromXRDS');
405
406     list($rp_url_after_redirects, $endpoints) =
407         Auth_Yadis_getServiceEndpoints($relying_party_url, $xrds_parse_cb,
408                                        $discover_function, $fetcher);
409
410     if ($rp_url_after_redirects != $relying_party_url) {
411         // Verification caused a redirect
412         return false;
413     }
414
415     call_user_func_array($discover_function,
416                          array($relying_party_url, $fetcher));
417
418     $return_to_urls = array();
419     $matching_endpoints = Auth_OpenID_extractReturnURL($endpoints);
420
421     foreach ($matching_endpoints as $e) {
422         $return_to_urls[] = $e->server_url;
423     }
424
425     return $return_to_urls;
426 }
427
428 /*
429  * Verify that a return_to URL is valid for the given realm.
430  *
431  * This function builds a discovery URL, performs Yadis discovery on
432  * it, makes sure that the URL does not redirect, parses out the
433  * return_to URLs, and finally checks to see if the current return_to
434  * URL matches the return_to.
435  *
436  * @return true if the return_to URL is valid for the realm
437  */
438 function Auth_OpenID_verifyReturnTo($realm_str, $return_to, $fetcher,
439               $_vrfy='Auth_OpenID_getAllowedReturnURLs')
440 {
441     $disco_url = Auth_OpenID_TrustRoot::buildDiscoveryURL($realm_str);
442
443     if ($disco_url === false) {
444         return false;
445     }
446
447     $allowable_urls = call_user_func_array($_vrfy,
448                            array($disco_url, $fetcher));
449
450     // The realm_str could not be parsed.
451     if ($allowable_urls === false) {
452         return false;
453     }
454
455     if (Auth_OpenID_returnToMatches($allowable_urls, $return_to)) {
456         return true;
457     } else {
458         return false;
459     }
460 }
461