2013-04-19 00:55:35 +00:00
< ? php /** @file */
2011-09-26 09:25:43 +00:00
/**
* Zot endpoint
*/
2012-08-09 01:50:04 +00:00
require_once ( 'include/zot.php' );
2013-01-22 03:16:21 +00:00
function post_init ( & $a ) {
2013-03-27 02:37:33 +00:00
// Most access to this endpoint is via the post method.
2013-01-22 03:16:21 +00:00
// Here we will pick out the magic auth params which arrive
2013-03-27 02:37:33 +00:00
// as a get request, and the only communications to arrive this way.
2013-01-22 03:16:21 +00:00
2013-12-02 01:12:29 +00:00
/**
* Magic Auth
* ==========
*
2013-12-03 01:35:44 +00:00
* So - called " magic auth " takes place by a special exchange . On the site where the " channel to be authenticated " lives ( e . g . $mysite ),
* a redirection is made via $mysite / magic to the zot endpoint of the remote site ( $remotesite ) with special GET parameters .
2013-12-02 01:12:29 +00:00
*
2013-12-03 01:35:44 +00:00
* The endpoint is typically https :// $remotesite / post - or whatever was specified as the callback url in prior communications
* ( we will bootstrap an address and fetch a zot info packet if possible where no prior communications exist )
2013-12-02 01:12:29 +00:00
*
2013-12-03 01:35:44 +00:00
* Four GET parameters are supplied :
2013-12-02 01:12:29 +00:00
*
2013-12-03 01:35:44 +00:00
** auth => the urlencoded webbie ( channel @ host . domain ) of the channel requesting access
2013-12-02 01:12:29 +00:00
** dest => the desired destination URL ( urlencoded )
2013-12-03 03:06:54 +00:00
** sec => a random string which is also stored on $mysite for use during the verification phase .
2013-12-02 01:12:29 +00:00
** version => the zot revision
*
2013-12-03 01:35:44 +00:00
* When this packet is received , an " auth-check " zot message is sent to $mysite .
2013-12-02 01:12:29 +00:00
* ( e . g . if $_GET [ 'auth' ] is foobar @ podunk . edu , a zot packet is sent to the podunk . edu zot endpoint , which is typically / post )
* If no information has been recorded about the requesting identity a zot information packet will be retrieved before
* continuing .
*
2013-12-04 00:31:05 +00:00
* The sender of this packet is an arbitrary / random site channel . The recipients will be a single recipient corresponding
2013-12-03 01:35:44 +00:00
* to the guid and guid_sig we have associated with the requesting auth identity
2013-12-02 01:12:29 +00:00
*
*
* {
* " type " : " auth_check " ,
* " sender " : {
* " guid " : " kgVFf_... " ,
* " guid_sig " : " PT9-TApz... " ,
* " url " : " http: \ / \ /podunk.edu " ,
* " url_sig " : " T8Bp7j... "
* },
* " recipients " : {
* {
* " guid " : " ZHSqb... " ,
* " guid_sig " : " JsAAXi... "
* }
* }
* " callback " : " \ /post " ,
* " version " : 1 ,
* " secret " : " 1eaa661 " ,
* " secret_sig " : " eKV968b1... "
* }
*
*
* auth_check messages MUST use encapsulated encryption . This message is sent to the origination site , which checks the 'secret' to see
* if it is the same as the 'sec' which it passed originally . It also checks the secret_sig which is the secret signed by the
* destination channel ' s private key and base64url encoded . If everything checks out , a json packet is returned :
*
* {
* " success " : 1 ,
* " confirm " : " q0Ysovd1u... "
2013-12-04 00:31:05 +00:00
* " service_class " : ( optional )
2013-12-23 23:13:09 +00:00
* " level " : ( optional )
2013-12-02 01:12:29 +00:00
* }
*
* 'confirm' in this case is the base64url encoded RSA signature of the concatenation of 'secret' with the
2013-12-03 01:35:44 +00:00
* base64url encoded whirlpool hash of the requestor ' s guid and guid_sig ; signed with the source channel private key .
2013-12-02 01:12:29 +00:00
* This prevents a man - in - the - middle from inserting a rogue success packet . Upon receipt and successful
* verification of this packet , the destination site will redirect to the original destination URL and indicate a successful remote login .
2013-12-04 00:31:05 +00:00
* Service_class can be used by cooperating sites to provide different access rights based on account rights and subscription plans . It is
* a string whose contents are not defined by protocol . Example : " basic " or " gold " .
2013-12-02 01:12:29 +00:00
*
*
*
*/
2013-11-18 08:55:41 +00:00
if ( array_key_exists ( 'auth' , $_REQUEST )) {
2013-12-05 23:40:50 +00:00
$ret = array ( 'success' => false , 'message' => '' );
2013-11-18 08:55:41 +00:00
logger ( 'mod_zot: auth request received.' );
$address = $_REQUEST [ 'auth' ];
2013-12-02 23:15:02 +00:00
$desturl = $_REQUEST [ 'dest' ];
2013-11-18 08:55:41 +00:00
$sec = $_REQUEST [ 'sec' ];
$version = $_REQUEST [ 'version' ];
2013-12-05 23:40:50 +00:00
$test = (( x ( $_REQUEST , 'test' )) ? intval ( $_REQUEST [ 'test' ]) : 0 );
2013-12-02 23:15:02 +00:00
2013-12-03 01:35:44 +00:00
// They are authenticating ultimately to the site and not to a particular channel.
// Any channel will do, providing it's currently active. We just need to have an
// identity to attach to the packet we send back. So find one.
2013-12-02 01:18:09 +00:00
2013-12-03 01:35:44 +00:00
$c = q ( " select * from channel where not ( channel_pageflags & %d ) limit 1 " ,
intval ( PAGE_REMOVED )
);
2013-12-02 01:12:29 +00:00
2013-12-03 01:35:44 +00:00
if ( ! $c ) {
// nobody here
logger ( 'mod_zot: auth: unable to find a response channel' );
2013-12-05 23:40:50 +00:00
if ( $test ) {
$ret [ 'message' ] .= 'no local channels found.' . EOL ;
json_return_and_die ( $ret );
}
2013-12-03 01:35:44 +00:00
goaway ( $desturl );
2013-11-18 08:55:41 +00:00
}
2013-01-22 03:16:21 +00:00
2013-11-18 08:55:41 +00:00
// Try and find a hubloc for the person attempting to auth
$x = q ( " select * from hubloc left join xchan on xchan_hash = hubloc_hash where hubloc_addr = '%s' order by hubloc_id desc limit 1 " ,
dbesc ( $address )
);
if ( ! $x ) {
// finger them if they can't be found.
$ret = zot_finger ( $address , null );
if ( $ret [ 'success' ]) {
$j = json_decode ( $ret [ 'body' ], true );
if ( $j )
import_xchan ( $j );
$x = q ( " select * from hubloc left join xchan on xchan_hash = hubloc_hash where hubloc_addr = '%s' order by hubloc_id desc limit 1 " ,
dbesc ( $address )
);
2013-01-25 03:45:08 +00:00
}
2013-11-18 08:55:41 +00:00
}
if ( ! $x ) {
logger ( 'mod_zot: auth: unable to finger ' . $address );
2013-12-05 23:40:50 +00:00
if ( $test ) {
$ret [ 'message' ] .= 'no hubloc found for ' . $address . ' and probing failed.' . EOL ;
json_return_and_die ( $ret );
}
2013-11-18 08:55:41 +00:00
goaway ( $desturl );
}
2013-01-25 03:45:08 +00:00
2013-12-05 07:54:46 +00:00
logger ( 'mod_zot: auth request received from ' . $x [ 0 ][ 'hubloc_addr' ] );
2013-01-22 03:16:21 +00:00
2013-11-18 08:55:41 +00:00
// check credentials and access
2013-01-22 03:16:21 +00:00
2013-11-18 08:55:41 +00:00
// If they are already authenticated and haven't changed credentials,
// we can save an expensive network round trip and improve performance.
2013-01-22 03:16:21 +00:00
2013-11-18 08:55:41 +00:00
$remote = remote_user ();
$result = null ;
2013-12-04 00:31:05 +00:00
$remote_service_class = '' ;
2013-12-23 23:13:09 +00:00
$remote_level = 0 ;
2013-12-04 00:31:05 +00:00
$remote_hub = $x [ 0 ][ 'hubloc_url' ];
2014-07-03 09:20:40 +00:00
$DNT = 0 ;
2013-01-22 03:16:21 +00:00
2013-12-05 07:54:46 +00:00
// Also check that they are coming from the same site as they authenticated with originally.
$already_authed = ((( $remote ) && ( $x [ 0 ][ 'hubloc_hash' ] == $remote ) && ( $x [ 0 ][ 'hubloc_url' ] === $_SESSION [ 'remote_hub' ])) ? true : false );
2013-01-24 00:06:01 +00:00
2013-12-05 23:40:50 +00:00
$j = array ();
2013-11-18 08:55:41 +00:00
if ( ! $already_authed ) {
2013-12-03 01:35:44 +00:00
// Auth packets MUST use ultra top-secret hush-hush mode - e.g. the entire packet is encrypted using the site private key
// The actual channel sending the packet ($c[0]) is not important, but this provides a generic zot packet with a sender
// which can be verified
$p = zot_build_packet ( $c [ 0 ], $type = 'auth_check' , array ( array ( 'guid' => $x [ 0 ][ 'hubloc_guid' ], 'guid_sig' => $x [ 0 ][ 'hubloc_guid_sig' ])), $x [ 0 ][ 'hubloc_sitekey' ], $sec );
2013-12-05 23:40:50 +00:00
if ( $test ) {
$ret [ 'message' ] .= 'auth check packet created using sitekey ' . $x [ 0 ][ 'hubloc_sitekey' ] . EOL ;
$ret [ 'message' ] .= 'packet contents: ' . $p . EOL ;
}
2013-11-18 08:55:41 +00:00
$result = zot_zot ( $x [ 0 ][ 'hubloc_callback' ], $p );
2013-12-05 23:40:50 +00:00
2013-11-18 08:55:41 +00:00
if ( ! $result [ 'success' ]) {
logger ( 'mod_zot: auth_check callback failed.' );
2013-12-05 23:40:50 +00:00
if ( $test ) {
2013-12-05 23:55:14 +00:00
$ret [ 'message' ] .= 'auth check request to your site returned .' . print_r ( $result , true ) . EOL ;
2013-12-05 23:40:50 +00:00
json_return_and_die ( $ret );
}
2013-11-18 08:55:41 +00:00
goaway ( $desturl );
2013-01-22 03:16:21 +00:00
}
2013-11-18 08:55:41 +00:00
$j = json_decode ( $result [ 'body' ], true );
2013-12-05 23:55:14 +00:00
if ( ! $j ) {
logger ( 'mod_zot: auth_check json data malformed.' );
if ( $test ) {
$ret [ 'message' ] .= 'json malformed: ' . $result [ 'body' ] . EOL ;
json_return_and_die ( $ret );
}
}
2013-11-18 08:55:41 +00:00
}
2013-01-22 03:16:21 +00:00
2013-12-05 23:55:14 +00:00
if ( $test ) {
$ret [ 'message' ] .= 'auth check request returned .' . print_r ( $j , true ) . EOL ;
}
2013-11-18 08:55:41 +00:00
if ( $already_authed || $j [ 'success' ]) {
if ( $j [ 'success' ]) {
// legit response, but we do need to check that this wasn't answered by a man-in-middle
if ( ! rsa_verify ( $sec . $x [ 0 ][ 'xchan_hash' ], base64url_decode ( $j [ 'confirm' ]), $x [ 0 ][ 'xchan_pubkey' ])) {
logger ( 'mod_zot: auth: final confirmation failed.' );
2013-12-05 23:40:50 +00:00
if ( $test ) {
$ret [ 'message' ] .= 'final confirmation failed. ' . $sec . print_r ( $j , true ) . print_r ( $x [ 0 ], true );
json_return_and_die ( $ret );
}
2013-11-18 08:55:41 +00:00
goaway ( $desturl );
2013-04-15 03:41:58 +00:00
}
2013-12-04 00:31:05 +00:00
if ( array_key_exists ( 'service_class' , $j ))
$remote_service_class = $j [ 'service_class' ];
2013-12-23 23:13:09 +00:00
if ( array_key_exists ( 'level' , $j ))
$remote_level = $j [ 'level' ];
2014-07-03 09:20:40 +00:00
if ( array_key_exists ( 'DNT' , $j ))
$DNT = $j [ 'DNT' ];
2013-11-18 08:55:41 +00:00
}
// everything is good... maybe
if ( local_user ()) {
2013-03-26 23:20:44 +00:00
2013-11-18 08:55:41 +00:00
// tell them to logout if they're logged in locally as anything but the target remote account
// in which case just shut up because they don't need to be doing this at all.
2013-03-26 23:20:44 +00:00
2013-11-18 08:55:41 +00:00
if ( $a -> channel [ 'channel_hash' ] != $x [ 0 ][ 'xchan_hash' ]) {
logger ( 'mod_zot: auth: already authenticated locally as somebody else.' );
notice ( t ( 'Remote authentication blocked. You are logged into this site locally. Please logout and retry.' ) . EOL );
2013-12-05 23:40:50 +00:00
if ( $test ) {
$ret [ 'message' ] .= 'already logged in locally with a conflicting identity.' . EOL ;
json_return_and_die ( $ret );
}
2013-01-24 00:06:01 +00:00
}
2013-11-18 08:55:41 +00:00
goaway ( $desturl );
2013-01-24 00:06:01 +00:00
}
2013-11-18 08:55:41 +00:00
// log them in
2013-12-04 00:31:05 +00:00
2013-12-05 23:40:50 +00:00
if ( $test ) {
$ret [ 'success' ] = true ;
2013-12-18 00:35:22 +00:00
$ret [ 'message' ] .= 'Authentication Success!' . EOL ;
2013-12-05 23:40:50 +00:00
json_return_and_die ( $ret );
}
2013-11-18 08:55:41 +00:00
$_SESSION [ 'authenticated' ] = 1 ;
$_SESSION [ 'visitor_id' ] = $x [ 0 ][ 'xchan_hash' ];
2014-03-04 23:25:04 +00:00
$_SESSION [ 'my_url' ] = $x [ 0 ][ 'xchan_url' ];
2013-11-18 08:55:41 +00:00
$_SESSION [ 'my_address' ] = $address ;
2013-12-04 00:31:05 +00:00
$_SESSION [ 'remote_service_class' ] = $remote_service_class ;
2013-12-23 23:13:09 +00:00
$_SESSION [ 'remote_level' ] = $remote_level ;
2013-12-04 00:31:05 +00:00
$_SESSION [ 'remote_hub' ] = $remote_hub ;
2014-07-03 09:20:40 +00:00
$_SESSION [ 'DNT' ] = $DNT ;
2013-12-04 00:31:05 +00:00
$arr = array ( 'xchan' => $x [ 0 ], 'url' => $desturl , 'session' => $_SESSION );
2013-11-18 08:55:41 +00:00
call_hooks ( 'magic_auth_success' , $arr );
$a -> set_observer ( $x [ 0 ]);
require_once ( 'include/security.php' );
$a -> set_groups ( init_groups_visitor ( $_SESSION [ 'visitor_id' ]));
info ( sprintf ( t ( 'Welcome %s. Remote authentication successful.' ), $x [ 0 ][ 'xchan_name' ]));
2013-12-04 00:31:05 +00:00
logger ( 'mod_zot: auth success from ' . $x [ 0 ][ 'xchan_addr' ]);
2014-01-30 19:41:40 +00:00
q ( " update hubloc set hubloc_status = (hubloc_status | %d ) where hubloc_id = %d " ,
intval ( HUBLOC_WORKS ),
intval ( $x [ 0 ][ 'hubloc_id' ])
);
2013-11-18 08:55:41 +00:00
} else {
2013-12-05 23:40:50 +00:00
if ( $test ) {
$ret [ 'message' ] .= 'auth failure. ' . print_r ( $_REQUEST , true ) . print_r ( $j , true ) . EOL ;
2014-03-13 02:04:20 +00:00
json_return_and_die ( $ret );
2013-12-05 23:40:50 +00:00
}
2013-12-03 01:35:44 +00:00
logger ( 'mod_zot: magic-auth failure - not authenticated: ' . $x [ 0 ][ 'xchan_addr' ]);
2013-12-04 08:19:29 +00:00
q ( " update hubloc set hubloc_status = (hubloc_status | %d ) where hubloc_id = %d " ,
2013-11-18 08:55:41 +00:00
intval ( HUBLOC_RECEIVE_ERROR ),
2013-12-04 08:19:29 +00:00
intval ( $x [ 0 ][ 'hubloc_id' ])
2013-11-18 08:55:41 +00:00
);
}
2013-02-13 10:33:13 +00:00
2013-11-18 08:55:41 +00:00
// FIXME - we really want to save the return_url in the session before we visit rmagic.
// This does however prevent a recursion if you visit rmagic directly, as it would otherwise send you back here again.
// But z_root() probably isn't where you really want to go.
2013-02-13 10:33:13 +00:00
2013-12-05 23:40:50 +00:00
if ( $test ) {
$ret [ 'message' ] .= 'auth failure fallthrough ' . print_r ( $_REQUEST , true ) . print_r ( $j , true ) . EOL ;
2014-03-13 02:09:45 +00:00
json_return_and_die ( $ret );
2013-12-05 23:40:50 +00:00
}
2013-11-18 08:55:41 +00:00
if ( strstr ( $desturl , z_root () . '/rmagic' ))
goaway ( z_root ());
2013-01-22 03:16:21 +00:00
2013-11-18 08:55:41 +00:00
goaway ( $desturl );
2013-01-22 03:16:21 +00:00
}
return ;
}
2013-12-02 00:11:18 +00:00
/**
* @ function post_post ( & $a )
* zot communications and messaging
*
* Sender HTTP posts to this endpoint ( $site / post typically ) with 'data' parameter set to json zot message packet .
* This packet is optionally encrypted , which we will discover if the json has an 'iv' element .
* $contents => array ( 'alg' => 'aes256cbc' , 'iv' => initialisation vector , 'key' => decryption key , 'data' => encrypted data );
2013-12-02 01:12:29 +00:00
* $contents -> iv and $contents -> key are random strings encrypted with this site ' s RSA public key and then base64url encoded .
2013-12-02 00:11:18 +00:00
* Currently only 'aes256cbc' is used , but this is extensible should that algorithm prove inadequate .
*
* Once decrypted , one will find the normal json_encoded zot message packet .
*
2014-02-11 22:19:20 +00:00
* Defined packet types are : notify , purge , refresh , force_refresh , auth_check , ping , and pickup
2013-12-02 03:02:36 +00:00
*
2014-02-11 22:19:20 +00:00
* Standard packet : ( used by notify , purge , refresh , force_refresh , and auth_check )
2013-12-02 03:02:36 +00:00
*
* {
* " type " : " notify " ,
* " sender " : {
* " guid " : " kgVFf_1... " ,
* " guid_sig " : " PT9-TApzp... " ,
* " url " : " http: \ / \ /podunk.edu " ,
* " url_sig " : " T8Bp7j5... " ,
* },
* " recipients " : { optional recipient array },
* " callback " : " \ /post " ,
* " version " : 1 ,
* " secret " : " 1eaa... " ,
* " secret_sig " : " df89025470fac8... "
* }
*
* Signature fields are all signed with the sender channel private key and base64url encoded .
* Recipients are arrays of guid and guid_sig , which were previously signed with the recipients private
* key and base64url encoded and later obtained via channel discovery . Absence of recipients indicates
* a public message or visible to all potential listeners on this site .
*
* " pickup " packet :
* The pickup packet is sent in response to a notify packet from another site
*
* {
* " type " : " pickup " ,
2013-12-02 00:11:18 +00:00
* " url " : " http: \ / \ /example.com " ,
* " callback " : " http: \ / \ /example.com \ /post " ,
* " callback_sig " : " teE1_fLI... " ,
* " secret " : " 1eaa... " ,
* " secret_sig " : " O7nB4_... "
* }
*
2013-12-02 03:02:36 +00:00
* In the pickup packet , the sig fields correspond to the respective data element signed with this site ' s system
* private key and then base64url encoded .
2013-12-02 00:11:18 +00:00
* The " secret " is the same as the original secret from the notify packet .
*
* If verification is successful , a json structure is returned
* containing a success indicator and an array of type 'pickup' .
* Each pickup element contains the original notify request and a message field whose contents are
* dependent on the message type
*
* This JSON array is AES encapsulated using the site public key of the site that sent the initial zot pickup packet .
* Using the above example , this would be example . com .
*
*
* {
* " success " : 1 ,
* " pickup " : {
* " notify " : {
* " type " : " notify " ,
* " sender " : {
* " guid " : " kgVFf_... " ,
* " guid_sig " : " PT9-TApz... " ,
* " url " : " http: \ / \ /z.podunk.edu " ,
* " url_sig " : " T8Bp7j5D... "
* },
* " callback " : " \ /post " ,
* " version " : 1 ,
* " secret " : " 1eaa661... "
* },
* " message " : {
* " type " : " activity " ,
* " message_id " : " 10b049ce384cbb2da9467319bc98169ab36290b8bbb403aa0c0accd9cb072e76@podunk.edu " ,
* " message_top " : " 10b049ce384cbb2da9467319bc98169ab36290b8bbb403aa0c0accd9cb072e76@podunk.edu " ,
* " message_parent " : " 10b049ce384cbb2da9467319bc98169ab36290b8bbb403aa0c0accd9cb072e76@podunk.edu " ,
* " created " : " 2012-11-20 04:04:16 " ,
* " edited " : " 2012-11-20 04:04:16 " ,
* " title " : " " ,
* " body " : " Hi Nickordo " ,
* " app " : " " ,
* " verb " : " post " ,
* " object_type " : " " ,
* " target_type " : " " ,
* " permalink " : " " ,
* " location " : " " ,
* " longlat " : " " ,
* " owner " : {
* " name " : " Indigo " ,
* " address " : " indigo@podunk.edu " ,
* " url " : " http: \ / \ /podunk.edu " ,
* " photo " : {
* " mimetype " : " image \ /jpeg " ,
* " src " : " http: \ / \ /podunk.edu \ /photo \ /profile \ /m \ /5 "
* },
* " guid " : " kgVFf_... " ,
* " guid_sig " : " PT9-TAp... " ,
* },
* " author " : {
* " name " : " Indigo " ,
* " address " : " indigo@podunk.edu " ,
* " url " : " http: \ / \ /podunk.edu " ,
* " photo " : {
* " mimetype " : " image \ /jpeg " ,
* " src " : " http: \ / \ /podunk.edu \ /photo \ /profile \ /m \ /5 "
* },
* " guid " : " kgVFf_... " ,
* " guid_sig " : " PT9-TAp... "
* }
* }
* }
* }
*
2014-09-13 23:00:09 +00:00
* Currently defined message types are 'activity' , 'mail' , 'profile' , 'location' and 'channel_sync' ,
* which each have different content schemas .
2013-12-02 03:02:36 +00:00
*
* Ping packet :
* A ping packet does not require any parameters except the type . It may or may not be encrypted .
*
* {
* " type " : " ping "
* }
*
* On receipt of a ping packet a ping response will be returned :
*
* {
* " success " : 1 ,
* " site " {
* " url " : " http: \ / \ /podunk.edu " ,
* " url_sig " : " T8Bp7j5... " ,
* " sitekey " : " -----BEGIN PUBLIC KEY-----
* MIICIjANBgkqhkiG9w0BAQE ... "
* }
* }
*
* The ping packet can be used to verify that a site has not been re - installed , and to
* initiate corrective action if it has . The url_sig is signed with the site private key
* and base64url encoded - and this should verify with the enclosed sitekey . Failure to
* verify indicates the site is corrupt or otherwise unable to communicate using zot .
* This return packet is not otherwise verified , so should be compared with other
* results obtained from this site which were verified prior to taking action . For instance
* if you have one verified result with this signature and key , and other records for this
* url which have different signatures and keys , it indicates that the site was re - installed
* and corrective action may commence ( remove or mark invalid any entries with different
* signatures ) .
* If you have no records which match this url_sig and key - no corrective action should
* be taken as this packet may have been returned by an imposter .
*
2013-12-02 00:11:18 +00:00
*/
2011-09-26 09:25:43 +00:00
function post_post ( & $a ) {
2012-11-13 04:59:18 +00:00
2013-12-03 01:35:44 +00:00
$encrypted_packet = false ;
2013-03-26 04:32:12 +00:00
$ret = array ( 'success' => false );
2011-09-26 09:25:43 +00:00
2012-11-20 04:45:12 +00:00
$data = json_decode ( $_REQUEST [ 'data' ], true );
2011-09-26 09:25:43 +00:00
2012-11-20 04:45:12 +00:00
2013-03-27 02:37:33 +00:00
/**
* Many message packets will arrive encrypted . The existence of an 'iv' element
* tells us we need to unencapsulate the AES - 256 - CBC content using the site private key
*/
2012-11-20 04:45:12 +00:00
if ( array_key_exists ( 'iv' , $data )) {
2013-12-03 01:35:44 +00:00
$encrypted_packet = true ;
2013-11-20 23:20:12 +00:00
$data = crypto_unencapsulate ( $data , get_config ( 'system' , 'prvkey' ));
2013-01-25 03:45:08 +00:00
logger ( 'mod_zot: decrypt1: ' . $data , LOGGER_DATA );
2012-11-20 04:45:12 +00:00
$data = json_decode ( $data , true );
2013-09-12 23:52:58 +00:00
}
if ( ! $data ) {
2013-09-24 12:20:29 +00:00
2013-09-24 19:04:01 +00:00
// possible Bleichenbacher's attack, just treat it as a
2013-09-24 12:20:29 +00:00
// message we have no handler for. It should fail a bit
// further along with "no hub". Our public key is public
// knowledge. There's no reason why anybody should get the
// encryption wrong unless they're fishing or hacking. If
// they're developing and made a goof, this can be discovered
// in the logs of the destination site. If they're fishing or
// hacking, the bottom line is we can't verify their hub.
// That's all we're going to tell them.
$data = array ( 'type' => 'bogus' );
2012-11-20 04:45:12 +00:00
}
2012-11-20 00:51:15 +00:00
2012-11-13 00:16:37 +00:00
$msgtype = (( array_key_exists ( 'type' , $data )) ? $data [ 'type' ] : '' );
2013-08-30 00:48:31 +00:00
if ( $msgtype === 'ping' ) {
// Useful to get a health check on a remote site.
// This will let us know if any important communication details
// that we may have stored are no longer valid, regardless of xchan details.
2014-01-27 11:01:53 +00:00
logger ( 'POST: got ping send pong now back: ' . z_root () , LOGGER_DEBUG );
2013-08-30 00:48:31 +00:00
$ret [ 'success' ] = true ;
$ret [ 'site' ] = array ();
$ret [ 'site' ][ 'url' ] = z_root ();
$ret [ 'site' ][ 'url_sig' ] = base64url_encode ( rsa_sign ( z_root (), get_config ( 'system' , 'prvkey' )));
$ret [ 'site' ][ 'sitekey' ] = get_config ( 'system' , 'pubkey' );
json_return_and_die ( $ret );
}
2012-11-20 04:45:12 +00:00
if ( $msgtype === 'pickup' ) {
2013-03-26 04:32:12 +00:00
/**
* The 'pickup' message arrives with a tracking ID which is associated with a particular outq_hash
* First verify that that the returned signatures verify , then check that we have an outbound queue item
* with the correct hash .
* If everything verifies , find any / all outbound messages in the queue for this hubloc and send them back
*
*/
2012-11-20 04:45:12 +00:00
if (( ! $data [ 'secret' ]) || ( ! $data [ 'secret_sig' ])) {
$ret [ 'message' ] = 'no verification signature' ;
2013-01-25 03:45:08 +00:00
logger ( 'mod_zot: pickup: ' . $ret [ 'message' ], LOGGER_DEBUG );
2012-11-20 04:45:12 +00:00
json_return_and_die ( $ret );
}
2013-05-17 04:06:01 +00:00
$r = q ( " select distinct hubloc_sitekey from hubloc where hubloc_url = '%s' and hubloc_callback = '%s' and hubloc_sitekey != '' group by hubloc_sitekey " ,
2012-11-20 04:45:12 +00:00
dbesc ( $data [ 'url' ]),
dbesc ( $data [ 'callback' ])
);
if ( ! $r ) {
$ret [ 'message' ] = 'site not found' ;
logger ( 'mod_zot: pickup: ' . $ret [ 'message' ]);
json_return_and_die ( $ret );
}
2013-05-17 03:21:12 +00:00
foreach ( $r as $hubsite ) {
// verify the url_sig
// If the server was re-installed at some point, there could be multiple hubs with the same url and callback.
// Only one will have a valid key.
$forgery = true ;
$secret_fail = true ;
$sitekey = $hubsite [ 'hubloc_sitekey' ];
2014-04-10 23:14:19 +00:00
logger ( 'mod_zot: Checking sitekey: ' . $sitekey , LOGGER_DATA );
2013-05-17 03:21:12 +00:00
if ( rsa_verify ( $data [ 'callback' ], base64url_decode ( $data [ 'callback_sig' ]), $sitekey )) {
$forgery = false ;
}
if ( rsa_verify ( $data [ 'secret' ], base64url_decode ( $data [ 'secret_sig' ]), $sitekey )) {
$secret_fail = false ;
}
if (( ! $forgery ) && ( ! $secret_fail ))
break ;
}
2013-11-21 22:42:48 +00:00
2013-05-17 03:21:12 +00:00
if ( $forgery ) {
2012-11-20 04:45:12 +00:00
$ret [ 'message' ] = 'possible site forgery' ;
logger ( 'mod_zot: pickup: ' . $ret [ 'message' ]);
json_return_and_die ( $ret );
}
2013-05-17 03:21:12 +00:00
if ( $secret_fail ) {
2012-11-20 04:45:12 +00:00
$ret [ 'message' ] = 'secret validation failed' ;
logger ( 'mod_zot: pickup: ' . $ret [ 'message' ]);
json_return_and_die ( $ret );
}
2013-03-26 04:32:12 +00:00
/**
* If we made it to here , the signatures verify , but we still don ' t know if the tracking ID is valid .
* It wouldn 't be an error if the tracking ID isn' t found , because we may have sent this particular
* queue item with another pickup ( after the tracking ID for the other pickup was verified ) .
*/
2012-11-20 04:45:12 +00:00
$r = q ( " select outq_posturl from outq where outq_hash = '%s' and outq_posturl = '%s' limit 1 " ,
dbesc ( $data [ 'secret' ]),
dbesc ( $data [ 'callback' ])
);
if ( ! $r ) {
$ret [ 'message' ] = 'nothing to pick up' ;
logger ( 'mod_zot: pickup: ' . $ret [ 'message' ]);
json_return_and_die ( $ret );
}
2013-03-26 04:32:12 +00:00
/**
* Everything is good if we made it here , so find all messages that are going to this location
* and send them all .
*/
2012-11-20 04:45:12 +00:00
$r = q ( " select * from outq where outq_posturl = '%s' " ,
dbesc ( $data [ 'callback' ])
);
if ( $r ) {
2014-05-06 03:15:01 +00:00
logger ( 'mod_zot: succesful pickup message received from ' . $data [ 'callback' ] . ' ' . count ( $r ) . ' message(s) picked up' , LOGGER_DEBUG );
2012-11-20 04:45:12 +00:00
$ret [ 'success' ] = true ;
$ret [ 'pickup' ] = array ();
foreach ( $r as $rr ) {
2012-11-27 05:20:16 +00:00
$ret [ 'pickup' ][] = array ( 'notify' => json_decode ( $rr [ 'outq_notify' ], true ), 'message' => json_decode ( $rr [ 'outq_msg' ], true ));
2012-11-20 04:45:12 +00:00
$x = q ( " delete from outq where outq_hash = '%s' limit 1 " ,
dbesc ( $rr [ 'outq_hash' ])
);
}
}
2013-11-21 22:42:48 +00:00
2013-11-20 23:20:12 +00:00
$encrypted = crypto_encapsulate ( json_encode ( $ret ), $sitekey );
2012-11-20 04:45:12 +00:00
json_return_and_die ( $encrypted );
2013-03-26 04:32:12 +00:00
/** pickup: end */
2012-11-20 04:45:12 +00:00
}
2013-03-26 04:32:12 +00:00
2013-12-03 01:35:44 +00:00
2013-03-26 04:32:12 +00:00
/**
* All other message types require us to verify the sender . This is a generic check , so we
* will do it once here and bail if anything goes wrong .
*/
2012-11-13 00:16:37 +00:00
if ( array_key_exists ( 'sender' , $data )) {
2012-11-20 00:51:15 +00:00
$sender = $data [ 'sender' ];
2012-11-11 07:26:12 +00:00
}
2013-03-26 04:32:12 +00:00
/** Check if the sender is already verified here */
2012-11-20 00:51:15 +00:00
$hub = zot_gethub ( $sender );
2013-03-26 04:32:12 +00:00
2012-11-11 04:08:07 +00:00
if ( ! $hub ) {
2013-03-26 04:32:12 +00:00
/** Have never seen this guid or this guid coming from this location. Check it and register it. */
2012-11-13 00:16:37 +00:00
// (!!) this will validate the sender
2012-11-20 00:51:15 +00:00
$result = zot_register_hub ( $sender );
2013-03-26 04:32:12 +00:00
2013-08-25 01:55:07 +00:00
if (( ! $result [ 'success' ]) || ( ! ( $hub = zot_gethub ( $sender )))) {
2012-11-11 04:08:07 +00:00
$ret [ 'message' ] = 'Hub not available.' ;
2012-11-13 04:59:18 +00:00
logger ( 'mod_zot: no hub' );
2012-11-11 04:08:07 +00:00
json_return_and_die ( $ret );
2012-08-10 03:31:06 +00:00
}
2012-11-11 04:08:07 +00:00
}
2013-08-25 01:55:07 +00:00
// Update our DB to show when we last communicated successfully with this hub
// This will allow us to prune dead hubs from using up resources
$r = q ( " update hubloc set hubloc_connected = '%s' where hubloc_id = %d limit 1 " ,
dbesc ( datetime_convert ()),
intval ( $hub [ 'hubloc_id' ])
);
2014-05-29 04:42:46 +00:00
// a dead hub came back to life - reset any tombstones we might have
if ( $hub [ 'hubloc_status' ] & HUBLOC_OFFLINE ) {
q ( " update hubloc set hubloc_status = (hubloc_status ^ %d) where hubloc_id = %d limit 1 " ,
intval ( HUBLOC_OFFLINE ),
intval ( $hub [ 'hubloc_id' ])
);
if ( $r [ 0 ][ 'hubloc_flags' ] & HUBLOC_FLAGS_ORPHANCHECK ) {
q ( " update hubloc set hubloc_flags = (hubloc_flags ^ %d) where hubloc_id = %d limit 1 " ,
intval ( HUBLOC_FLAGS_ORPHANCHECK ),
intval ( $hub [ 'hubloc_id' ])
);
}
q ( " update xchan set xchan_flags = (xchan_flags ^ %d) where (xchan_flags & %d) and xchan_hash = '%s' limit 1 " ,
intval ( XCHAN_FLAGS_ORPHAN ),
intval ( XCHAN_FLAGS_ORPHAN ),
dbesc ( $hub [ 'hubloc_hash' ])
);
}
2013-11-21 22:42:48 +00:00
/**
* This hub has now been proven to be valid .
* Any hub with the same URL and a different sitekey cannot be valid .
* Get rid of them ( mark them deleted ) . There ' s a good chance they were re - installs .
*
*/
q ( " update hubloc set hubloc_flags = ( hubloc_flags | %d ) where hubloc_url = '%s' and hubloc_sitekey != '%s' " ,
intval ( HUBLOC_FLAGS_DELETED ),
dbesc ( $hub [ 'hubloc_url' ]),
dbesc ( $hub [ 'hubloc_sitekey' ])
);
2013-08-25 01:55:07 +00:00
2012-11-13 00:16:37 +00:00
// TODO: check which hub is primary and take action if mismatched
2012-11-11 04:08:07 +00:00
2012-11-13 00:16:37 +00:00
if ( array_key_exists ( 'recipients' , $data ))
2012-11-20 00:51:15 +00:00
$recipients = $data [ 'recipients' ];
2012-11-11 04:08:07 +00:00
2013-12-03 01:35:44 +00:00
if ( $msgtype === 'auth_check' ) {
2013-12-03 03:06:54 +00:00
/**
* Requestor visits / magic / ? dest = somewhere on their own site with a browser
* magic redirects them to $destsite / post [ with auth args .... ]
* $destsite sends an auth_check packet to originator site
* The auth_check packet is handled here by the originator ' s site
* - the browser session is still waiting
* inside $destsite / post for everything to verify
* If everything checks out we ' ll return a token to $destsite
* and then $destsite will verify the token , authenticate the browser
* session and then redirect to the original destination .
* If authentication fails , the redirection to the original destination
* will still take place but without authentication .
*/
2013-12-03 01:35:44 +00:00
logger ( 'mod_zot: auth_check' , LOGGER_DEBUG );
if ( ! $encrypted_packet ) {
logger ( 'mod_zot: auth_check packet was not encrypted.' );
2013-12-05 23:40:50 +00:00
$ret [ 'message' ] .= 'no packet encryption' . EOL ;
2013-12-03 01:35:44 +00:00
json_return_and_die ( $ret );
}
$arr = $data [ 'sender' ];
2014-07-15 04:21:24 +00:00
$sender_hash = make_xchan_hash ( $arr [ 'guid' ], $arr [ 'guid_sig' ]);
2013-12-03 01:35:44 +00:00
// garbage collect any old unused notifications
q ( " delete from verify where type = 'auth' and created < UTC_TIMESTAMP() - INTERVAL 10 MINUTE " );
$y = q ( " select xchan_pubkey from xchan where xchan_hash = '%s' limit 1 " ,
dbesc ( $sender_hash )
);
// We created a unique hash in mod/magic.php when we invoked remote auth, and stored it in
// the verify table. It is now coming back to us as 'secret' and is signed by a channel at the other end.
// First verify their signature. We will have obtained a zot-info packet from them as part of the sender
// verification.
if (( ! $y ) || ( ! rsa_verify ( $data [ 'secret' ], base64url_decode ( $data [ 'secret_sig' ]), $y [ 0 ][ 'xchan_pubkey' ]))) {
logger ( 'mod_zot: auth_check: sender not found or secret_sig invalid.' );
2013-12-05 23:40:50 +00:00
$ret [ 'message' ] .= 'sender not found or sig invalid ' . print_r ( $y , true ) . EOL ;
2013-12-03 01:35:44 +00:00
json_return_and_die ( $ret );
}
// There should be exactly one recipient, the original auth requestor
2013-12-05 23:40:50 +00:00
$ret [ 'message' ] .= 'recipients ' . print_r ( $recipients , true ) . EOL ;
2013-12-03 01:35:44 +00:00
if ( $data [ 'recipients' ]) {
$arr = $data [ 'recipients' ][ 0 ];
2014-07-15 04:21:24 +00:00
$recip_hash = make_xchan_hash ( $arr [ 'guid' ], $arr [ 'guid_sig' ]);
2013-12-04 00:31:05 +00:00
$c = q ( " select channel_id, channel_account_id, channel_prvkey from channel where channel_hash = '%s' limit 1 " ,
2013-12-03 01:35:44 +00:00
dbesc ( $recip_hash )
);
if ( ! $c ) {
logger ( 'mod_zot: auth_check: recipient channel not found.' );
2013-12-05 23:40:50 +00:00
$ret [ 'message' ] .= 'recipient not found.' . EOL ;
2013-12-03 01:35:44 +00:00
json_return_and_die ( $ret );
}
$confirm = base64url_encode ( rsa_sign ( $data [ 'secret' ] . $recip_hash , $c [ 0 ][ 'channel_prvkey' ]));
// This additionally checks for forged sites since we already stored the expected result in meta
// and we've already verified that this is them via zot_gethub() and that their key signed our token
$z = q ( " select id from verify where channel = %d and type = 'auth' and token = '%s' and meta = '%s' limit 1 " ,
intval ( $c [ 0 ][ 'channel_id' ]),
dbesc ( $data [ 'secret' ]),
dbesc ( $data [ 'sender' ][ 'url' ])
);
if ( ! $z ) {
logger ( 'mod_zot: auth_check: verification key not found.' );
2013-12-05 23:40:50 +00:00
$ret [ 'message' ] .= 'verification key not found' . EOL ;
2013-12-03 01:35:44 +00:00
json_return_and_die ( $ret );
}
$r = q ( " delete from verify where id = %d limit 1 " ,
intval ( $z [ 0 ][ 'id' ])
);
2013-12-04 00:31:05 +00:00
$u = q ( " select account_service_class from account where account_id = %d limit 1 " ,
intval ( $c [ 0 ][ 'channel_account_id' ])
);
2013-12-03 01:35:44 +00:00
logger ( 'mod_zot: auth_check: success' , LOGGER_DEBUG );
$ret [ 'success' ] = true ;
$ret [ 'confirm' ] = $confirm ;
2013-12-04 00:31:05 +00:00
if ( $u && $u [ 0 ][ 'account_service_class' ])
$ret [ 'service_class' ] = $u [ 0 ][ 'account_service_class' ];
2014-07-04 00:26:42 +00:00
// Set "do not track" flag if this site or this channel's profile is restricted
if ( intval ( get_config ( 'system' , 'block_public' )))
$ret [ 'DNT' ] = true ;
if ( ! perm_is_allowed ( $c [ 0 ][ 'channel_id' ], '' , 'view_profile' ))
$ret [ 'DNT' ] = true ;
2014-07-15 04:21:24 +00:00
if ( get_pconfig ( $c [ 0 ][ 'channel_id' ], 'system' , 'do_not_track' ))
$ret [ 'DNT' ] = true ;
2014-07-04 00:26:42 +00:00
2013-12-03 01:35:44 +00:00
json_return_and_die ( $ret );
}
json_return_and_die ( $ret );
}
2013-02-18 23:15:55 +00:00
if ( $msgtype === 'purge' ) {
if ( $recipients ) {
// basically this means "unfriend"
foreach ( $recipients as $recip ) {
2013-08-05 02:09:53 +00:00
$r = q ( " select channel.*,xchan.* from channel
left join xchan on channel_hash = xchan_hash
where channel_guid = '%s' and channel_guid_sig = '%s' limit 1 " ,
dbesc ( $recip [ 'guid' ]),
dbesc ( $recip [ 'guid_sig' ])
);
if ( $r ) {
$r = q ( " select abook_id from abook where uid = %d and abook_xchan = '%s' limit 1 " ,
intval ( $r [ 0 ][ 'channel_id' ]),
2014-07-15 04:21:24 +00:00
dbesc ( make_xchan_hash ( $sender [ 'guid' ], $sender [ 'guid_sig' ]))
2013-08-05 02:09:53 +00:00
);
if ( $r ) {
contact_remove ( $r [ 0 ][ 'channel_id' ], $r [ 0 ][ 'abook_id' ]);
}
}
2013-02-18 23:15:55 +00:00
}
}
else {
2013-03-26 04:32:12 +00:00
// Unfriend everybody - basically this means the channel has committed suicide
2013-02-18 23:15:55 +00:00
$arr = $data [ 'sender' ];
2014-07-15 04:21:24 +00:00
$sender_hash = make_xchan_hash ( $arr [ 'guid' ], $arr [ 'guid_sig' ]);
2013-02-18 23:15:55 +00:00
require_once ( 'include/Contact.php' );
remove_all_xchan_resources ( $sender_hash );
2013-03-26 04:32:12 +00:00
$ret [ 'success' ] = true ;
2013-02-18 23:15:55 +00:00
json_return_and_die ( $ret );
}
}
2013-03-11 01:45:58 +00:00
2014-02-11 22:19:20 +00:00
if (( $msgtype === 'refresh' ) || ( $msgtype === 'force_refresh' )) {
2012-11-11 04:08:07 +00:00
2012-11-13 00:16:37 +00:00
// remote channel info (such as permissions or photo or something)
// has been updated. Grab a fresh copy and sync it.
2014-02-11 22:19:20 +00:00
// The difference between refresh and force_refresh is that
// force_refresh unconditionally creates a directory update record,
// even if no changes were detected upon processing.
2012-11-11 04:08:07 +00:00
2012-11-20 00:51:15 +00:00
if ( $recipients ) {
2012-11-11 04:08:07 +00:00
2012-11-13 00:16:37 +00:00
// This would be a permissions update, typically for one connection
2012-11-11 04:08:07 +00:00
2012-11-20 00:51:15 +00:00
foreach ( $recipients as $recip ) {
2012-11-13 00:16:37 +00:00
$r = q ( " select channel.*,xchan.* from channel
left join xchan on channel_hash = xchan_hash
where channel_guid = '%s' and channel_guid_sig = '%s' limit 1 " ,
2012-11-20 00:51:15 +00:00
dbesc ( $recip [ 'guid' ]),
dbesc ( $recip [ 'guid_sig' ])
2012-11-13 00:16:37 +00:00
);
2012-11-11 04:08:07 +00:00
2012-11-13 00:16:37 +00:00
$x = zot_refresh ( array (
2012-11-20 00:51:15 +00:00
'xchan_guid' => $sender [ 'guid' ],
'xchan_guid_sig' => $sender [ 'guid_sig' ],
'hubloc_url' => $sender [ 'url' ]
2014-02-11 22:19:20 +00:00
), $r [ 0 ], (( $msgtype === 'force_refresh' ) ? true : false ));
2012-11-13 00:16:37 +00:00
}
}
else {
// system wide refresh
$x = zot_refresh ( array (
2012-11-20 00:51:15 +00:00
'xchan_guid' => $sender [ 'guid' ],
'xchan_guid_sig' => $sender [ 'guid_sig' ],
'hubloc_url' => $sender [ 'url' ]
2014-02-14 20:39:15 +00:00
), null ,(( $msgtype === 'force_refresh' ) ? true : false ));
2012-11-13 00:16:37 +00:00
}
2013-03-26 04:32:12 +00:00
$ret [ 'success' ] = true ;
2012-11-13 00:16:37 +00:00
json_return_and_die ( $ret );
2012-11-11 04:08:07 +00:00
}
if ( $msgtype === 'notify' ) {
2012-11-20 04:45:12 +00:00
$async = get_config ( 'system' , 'queued_fetch' );
if ( $async ) {
// add to receive queue
// qreceive_add($data);
}
else {
$x = zot_fetch ( $data );
2013-01-01 05:33:11 +00:00
$ret [ 'delivery_report' ] = $x ;
2012-11-20 04:45:12 +00:00
}
2011-09-26 09:25:43 +00:00
2013-03-26 04:32:12 +00:00
$ret [ 'success' ] = true ;
2012-08-09 01:50:04 +00:00
json_return_and_die ( $ret );
2012-11-20 00:51:15 +00:00
2012-08-09 01:50:04 +00:00
}
2011-09-26 09:25:43 +00:00
2013-01-22 03:16:21 +00:00
// catchall
json_return_and_die ( $ret );
}
2012-08-09 01:50:04 +00:00