]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - plugins/Diaspora/DiasporaPlugin.php
75dba7384a487a87e7849d163f02807bc0b9947b
[quix0rs-gnu-social.git] / plugins / Diaspora / DiasporaPlugin.php
1 <?php
2 /*
3  * GNU Social - a federating social network
4  * Copyright (C) 2015, Free Software Foundation, Inc.
5  *
6  * This program is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU Affero General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Affero General Public License for more details.
15  *
16  * You should have received a copy of the GNU Affero General Public License
17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 if (!defined('GNUSOCIAL')) { exit(1); }
21
22 /**
23  * Diaspora federation protocol plugin for GNU Social
24  *
25  * Depends on:
26  *  - OStatus plugin
27  *  - WebFinger plugin
28  *
29  * @package ProtocolDiasporaPlugin
30  * @maintainer Mikael Nordfeldth <mmn@hethane.se>
31  */
32
33 // Depends on OStatus of course.
34 addPlugin('OStatus');
35
36 //Since Magicsig hasn't loaded yet
37 require_once('Crypt/AES.php');
38
39 class DiasporaPlugin extends Plugin
40 {
41     const REL_SEED_LOCATION = 'http://joindiaspora.com/seed_location';
42     const REL_GUID          = 'http://joindiaspora.com/guid';
43     const REL_PUBLIC_KEY    = 'diaspora-public-key';
44
45     public function onEndAttachPubkeyToUserXRD(Magicsig $magicsig, XML_XRD $xrd, Profile $target)
46     {
47         // So far we've only handled RSA keys, but it can change in the future,
48         // so be prepared. And remember to change the statically assigned type attribute below!
49         assert($magicsig->publicKey instanceof Crypt_RSA);
50         $xrd->links[] = new XML_XRD_Element_Link(self::REL_PUBLIC_KEY,
51                                     base64_encode($magicsig->exportPublicKey()), 'RSA');
52
53         // Instead of choosing a random string, we calculate our GUID from the public key
54         // by fingerprint through a sha256 hash.
55         $xrd->links[] = new XML_XRD_Element_Link(self::REL_GUID,
56                                     strtolower($magicsig->toFingerprint()));
57     }
58
59     public function onMagicsigPublicKeyFromXRD(XML_XRD $xrd, &$pubkey)
60     {
61         // See if we have a Diaspora public key in the XRD response
62         $link = $xrd->get(self::REL_PUBLIC_KEY, 'RSA');
63         if (!is_null($link)) {
64             // If we do, decode it so we have the PKCS1 format (starts with -----BEGIN PUBLIC KEY-----)
65             $pkcs1 = base64_decode($link->href);
66             $magicsig = new Magicsig(Magicsig::DEFAULT_SIGALG); // Diaspora uses RSA-SHA256 (we do too)
67             try {
68                 // Try to load the public key so we can get it in the standard Magic signature format
69                 $magicsig->loadPublicKeyPKCS1($pkcs1);
70                 // We found it and will now store it in $pubkey in a proper format!
71                 // This is how it would be found in a well implemented XRD according to the standard.
72                 $pubkey = 'data:application/magic-public-key,'.$magicsig->toString();
73                 common_debug('magic-public-key found in diaspora-public-key: '.$pubkey);
74                 return false;
75             } catch (ServerException $e) {
76                 common_log(LOG_WARNING, $e->getMessage());
77             }
78         }
79         return true;
80     }
81
82     public function onPluginVersion(array &$versions)
83     {
84         $versions[] = array('name' => 'Diaspora',
85                             'version' => '0.1',
86                             'author' => 'Mikael Nordfeldth',
87                             'homepage' => 'https://gnu.io/social',
88                             // TRANS: Plugin description.
89                             'rawdescription' => _m('Follow people across social networks that implement '.
90                                'the <a href="https://diasporafoundation.org/">Diaspora</a> federation protocol.'));
91
92         return true;
93     }
94
95     public function onStartMagicEnvelopeToXML(MagicEnvelope $magic_env, XMLStringer $xs, $flavour=null, Profile $target=null)
96     {
97         // Since Diaspora doesn't use a separate namespace for their "extended"
98         // salmon slap, we'll have to resort to this workaround hack.
99         if ($flavour !== 'diaspora') {
100             return true;
101         }
102
103         // WARNING: This changes the $magic_env contents! Be aware of it.
104
105         /**
106          * https://wiki.diasporafoundation.org/Federation_protocol_overview
107          *
108          * Constructing the encryption header
109          */
110
111         /**
112          * Choose an AES key and initialization vector, suitable for the
113          * aes-256-cbc cipher. I shall refer to this as the “inner key”
114          * and the “inner initialization vector (iv)”.
115          */
116         $inner_key = new Crypt_AES(CRYPT_AES_MODE_CBC);
117         $inner_key->setKeyLength(256);  // set length to 256 bits (could be calculated, but let's be sure)
118         $inner_key->setKey(common_random_rawstr(32));   // 32 bytes from a (pseudo) random source
119         $inner_key->setIV(common_random_rawstr(16));    // 16 bytes is the block length
120
121         /**
122          * Construct the following XML snippet:
123          *  <decrypted_header>
124          *      <iv>((base64-encoded inner iv))</iv>
125          *      <aes_key>((base64-encoded inner key))</aes_key>
126          *      <author>
127          *          <name>Alice Exampleman</name>
128          *          <uri>acct:user@sender.example</uri>
129          *      </author>
130          *  </decrypted_header>
131          */
132         $decrypted_header = sprintf('<decrypted_header><iv>%1$s</iv><aes_key>%2$s</aes_key><author_id>%3$s</author_id></decrypted_header>',
133                                     base64_encode($inner_key->iv),
134                                     base64_encode($inner_key->key),
135                                     $magic_env->getActor()->getAcctUri());
136
137         /**
138          * Construct another AES key and initialization vector suitable
139          * for the aes-256-cbc cipher. I shall refer to this as the
140          * “outer key” and the “outer initialization vector (iv)”.
141          */
142         $outer_key = new Crypt_AES(CRYPT_AES_MODE_CBC);
143         $outer_key->setKeyLength(256);  // set length to 256 bits (could be calculated, but let's be sure)
144         $outer_key->setKey(common_random_rawstr(32));   // 32 bytes from a (pseudo) random source
145         $outer_key->setIV(common_random_rawstr(16));    // 16 bytes is the block length
146
147         /**
148          * Encrypt your <decrypted_header> XML snippet using the “outer key”
149          * and “outer iv” (using the aes-256-cbc cipher). This encrypted
150          * blob shall be referred to as “the ciphertext”. 
151          */
152         $ciphertext = $outer_key->encrypt($decrypted_header);
153
154         /**
155          * Construct the following JSON object, which shall be referred to
156          * as “the outer aes key bundle”:
157          *  {
158          *      "iv": ((base64-encoded AES outer iv)),
159          *      "key": ((base64-encoded AES outer key))
160          *  }
161          */
162         $outer_bundle = json_encode(array(
163                                 'iv' => base64_encode($outer_key->iv),
164                                 'key' => base64_encode($outer_key->key),
165                             ));
166         /**
167          * Encrypt the “outer aes key bundle” with Bob’s RSA public key.
168          * I shall refer to this as the “encrypted outer aes key bundle”.
169          */
170         common_debug('Diaspora creating "outer aes key bundle", will require magic-public-key');
171         $key_fetcher = new MagicEnvelope();
172         $remote_keys = $key_fetcher->getKeyPair($target, true); // actually just gets the public key
173         $enc_outer = $remote_keys->publicKey->encrypt($outer_bundle);
174
175         /**
176          * Construct the following JSON object, which I shall refer to as
177          * the “encrypted header json object”:
178          *  {
179          *      "aes_key": ((base64-encoded encrypted outer aes key bundle)),
180          *      "ciphertext": ((base64-encoded ciphertextm from above))
181          *  }
182          */
183         $enc_header = json_encode(array(
184                             'aes_key' => base64_encode($enc_outer),
185                             'ciphertext' => base64_encode($ciphertext),
186                         ));
187
188         /**
189          * Construct the xml snippet:
190          *  <encrypted_header>((base64-encoded encrypted header json object))</encrypted_header>
191          */
192         $xs->element('encrypted_header', null, base64_encode($enc_header));
193
194         /**
195          * In order to prepare the payload message for inclusion in your
196          * salmon slap, you will:
197          *
198          * 1. Encrypt the payload message using the aes-256-cbc cipher and
199          *      the “inner encryption key” and “inner encryption iv” you
200          *      chose earlier.
201          * 2. Base64-encode the encrypted payload message.
202          */
203         $payload = $inner_key->encrypt($magic_env->getData());
204         $magic_env->signMessage(base64_encode($payload), 'application/xml');
205
206
207         // Since we have to change the content of me:data we'll just write the
208         // whole thing from scratch. We _could_ otherwise have just manipulated
209         // that element and added the encrypted_header in the EndMagicEnvelopeToXML event.
210         $xs->elementStart('me:env', array('xmlns:me' => MagicEnvelope::NS));
211         $xs->element('me:data', array('type' => $magic_env->getDataType()), $magic_env->getData());
212         $xs->element('me:encoding', null, $magic_env->getEncoding());
213         $xs->element('me:alg', null, $magic_env->getSignatureAlgorithm());
214         $xs->element('me:sig', null, $magic_env->getSignature());
215         $xs->elementEnd('me:env');
216
217         return false;
218     }
219
220     public function onSalmonSlap($endpoint_uri, MagicEnvelope $magic_env, Profile $target=null)
221     {
222         $envxml = $magic_env->toXML($target, 'diaspora');
223
224         // Diaspora wants another POST format (base64url-encoded POST variable 'xml')
225         $headers = array('Content-Type: application/x-www-form-urlencoded');
226
227         // Another way to distinguish Diaspora from GNU social is that a POST with
228         // $headers=array('Content-Type: application/magic-envelope+xml') would return
229         // HTTP status code 422 Unprocessable Entity, at least as of 2015-10-04.
230         try {
231             $client = new HTTPClient();
232             $client->setBody('xml=' . Magicsig::base64_url_encode($envxml));
233             $response = $client->post($endpoint_uri, $headers);
234         } catch (HTTP_Request2_Exception $e) {
235             common_log(LOG_ERR, "Diaspora-flavoured Salmon post to $endpoint_uri failed: " . $e->getMessage());
236             return false;
237         }
238
239         // 200 OK is the best response
240         // 202 Accepted is what we get from Diaspora for example
241         if (!in_array($response->getStatus(), array(200, 202))) {
242             common_log(LOG_ERR, sprintf('Salmon (from profile %d) endpoint %s returned status %s: %s',
243                                 $magic_env->getActor()->getID(), $endpoint_uri, $response->getStatus(), $response->getBody()));
244             return true;
245         }
246
247         // Success!
248         return false;
249     }
250 }