js: Error handling for browser errors
[gpgme.git] / lang / js / src / permittedOperations.js
1 /* gpgme.js - Javascript integration for gpgme
2  * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
3  *
4  * This file is part of GPGME.
5  *
6  * GPGME is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * GPGME is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <https://www.gnu.org/licenses/>.
18  * SPDX-License-Identifier: LGPL-2.1+
19  *
20  * Author(s):
21  *     Maximilian Krambach <mkrambach@intevation.de>
22  */
23
24 /**
25  * @typedef {Object} messageProperty
26  * A message Property is defined by it's key.
27  * @property {Array<String>} allowed Array of allowed types.
28  * Currently accepted values are 'number', 'string', 'boolean'.
29  * @property {Boolean} array_allowed If the value can be an array of types
30  *      defined in allowed
31  * @property {Array<*>} allowed_data (optional) restricts to the given values
32   */
33
34 /**
35  * Definition of the possible interactions with gpgme-json.
36  * @param {Object} operation Each operation is named by a key and contains
37  * the following properties:
38  * @property {messageProperty} required An object with all required parameters
39  * @property {messageProperty} optional An object with all optional parameters
40  * @property {Boolean} pinentry (optional) If true, a password dialog is
41  *      expected, thus a connection tuimeout is not advisable
42  * @property {Object} answer The definition on what to expect as answer, if the
43  *      answer is not an error
44  * @property {Array<String>} answer.type the type(s) as reported by gpgme-json.
45  * @property {Object} answer.payload key-value combinations of expected
46  * properties of an answer and their type ('boolean', 'string', object), which
47  * may need further decoding from base64
48  * @property {Object} answer.info key-value combinations of expected
49  * properties of an answer and their type ('boolean', 'string', object), which
50  * are meant to be data directly sent by gpgme (i.e. user ids)
51   @const
52 */
53 export const permittedOperations = {
54     encrypt: {
55         pinentry: true, // TODO only with signing_keys
56         required: {
57             'keys': {
58                 allowed: ['string'],
59                 array_allowed: true
60             },
61             'data': {
62                 allowed: ['string']
63             }
64         },
65         optional: {
66             'protocol': {
67                 allowed: ['string'],
68                 allowed_data: ['cms', 'openpgp']
69             },
70             'signing_keys': {
71                 allowed: ['string'],
72                 array_allowed: true
73             },
74             'base64': {
75                 allowed: ['boolean']
76             },
77             'mime': {
78                 allowed: ['boolean']
79             },
80             'armor': {
81                 allowed: ['boolean']
82             },
83             'always-trust': {
84                 allowed: ['boolean']
85             },
86             'no-encrypt-to': {
87                 allowed: ['string'],
88                 array_allowed: true
89             },
90             'no-compress': {
91                 allowed: ['boolean']
92             },
93             'throw-keyids': {
94                 allowed: ['boolean']
95             },
96             'want-address': {
97                 allowed: ['boolean']
98             },
99             'wrap': {
100                 allowed: ['boolean']
101             },
102             'sender': {
103                 allowed: ['string']
104             },
105             'file_name': {
106                 allowed: ['string']
107             }
108         },
109         answer: {
110             type: ['ciphertext'],
111             payload: {
112                 'data': 'string'
113             },
114             info: {
115                 'base64':'boolean'
116             }
117         }
118     },
119
120     decrypt: {
121         pinentry: true,
122         required: {
123             'data': {
124                 allowed: ['string']
125             }
126         },
127         optional: {
128             'protocol': {
129                 allowed: ['string'],
130                 allowed_data: ['cms', 'openpgp']
131             },
132             'base64': {
133                 allowed: ['boolean']
134             }
135         },
136         answer: {
137             type: ['plaintext'],
138             payload: {
139                 'data': 'string',
140             },
141             info: {
142                 'base64': 'boolean',
143                 'mime': 'boolean',
144                 'info': 'object',
145                 'dec_info': 'object'
146             }
147         }
148     },
149
150     sign: {
151         pinentry: true,
152         required: {
153             'data': {
154                 allowed: ['string'] },
155             'keys': {
156                 allowed: ['string'],
157                 array_allowed: true
158             }
159         },
160         optional: {
161             'protocol': {
162                 allowed: ['string'],
163                 allowed_data: ['cms', 'openpgp']
164             },
165             'sender': {
166                 allowed: ['string'],
167             },
168             'mode': {
169                 allowed: ['string'],
170                 allowed_data: ['detached', 'clearsign']
171                 // TODO 'opaque' is not used, but available on native app
172             },
173             'base64': {
174                 allowed: ['boolean']
175             },
176             'armor': {
177                 allowed: ['boolean']
178             },
179         },
180         answer: {
181             type: ['signature', 'ciphertext'],
182             payload: {
183                 'data': 'string',
184             },
185             info: {
186                 'base64':'boolean'
187             }
188         }
189     },
190
191     // note: For the meaning of the optional keylist flags, refer to
192     // https://www.gnupg.org/documentation/manuals/gpgme/Key-Listing-Mode.html
193     keylist:{
194         required: {},
195
196         optional: {
197             'protocol': {
198                 allowed: ['string'],
199                 allowed_data: ['cms', 'openpgp']
200             },
201             'secret': {
202                 allowed: ['boolean']
203             },
204             'extern': {
205                 allowed: ['boolean']
206             },
207             'local':{
208                 allowed: ['boolean']
209             },
210             'locate': {
211                 allowed: ['boolean']
212             },
213             'sigs':{
214                 allowed: ['boolean']
215             },
216             'notations':{
217                 allowed: ['boolean']
218             },
219             'tofu': {
220                 allowed: ['boolean']
221             },
222             'ephemeral': {
223                 allowed: ['boolean']
224             },
225             'validate': {
226                 allowed: ['boolean']
227             },
228             'keys': {
229                 allowed: ['string'],
230                 array_allowed: true
231             }
232         },
233         answer: {
234             type: ['keys'],
235             info: {
236                 'keys': 'object',
237                 'base64': 'boolean',
238             }
239         }
240     },
241
242     export: {
243         required: {},
244         optional: {
245             'protocol': {
246                 allowed: ['string'],
247                 allowed_data: ['cms', 'openpgp']
248             },
249             'keys': {
250                 allowed: ['string'],
251                 array_allowed: true
252             },
253             'armor': {
254                 allowed: ['boolean']
255             },
256             'extern': {
257                 allowed: ['boolean']
258             },
259             'minimal': {
260                 allowed: ['boolean']
261             },
262             'raw': {
263                 allowed: ['boolean']
264             },
265             'pkcs12': {
266                 allowed: ['boolean']
267             },
268             'with-sec-fprs': {
269                 allowed: ['boolean']
270             }
271             // secret: not yet implemented
272         },
273         answer: {
274             type: ['keys'],
275             payload: {
276                 'data': 'string',
277             },
278             info: {
279                 'base64': 'boolean',
280                 'sec-fprs': 'object'
281             }
282         }
283     },
284
285     import: {
286         required: {
287             'data': {
288                 allowed: ['string']
289             }
290         },
291         optional: {
292             'protocol': {
293                 allowed: ['string'],
294                 allowed_data: ['cms', 'openpgp']
295             },
296             'base64': {
297                 allowed: ['boolean']
298             },
299         },
300         answer: {
301             type: [],
302             info: {
303                 'result': 'object'
304             }
305         }
306     },
307
308     delete: {
309         pinentry: true,
310         required:{
311             'key': {
312                 allowed: ['string']
313             }
314         },
315         optional: {
316             'protocol': {
317                 allowed: ['string'],
318                 allowed_data: ['cms', 'openpgp']
319             },
320         },
321         answer: {
322             info: {
323                 'success': 'boolean'
324             }
325         }
326     },
327
328     version: {
329         required: {},
330         optional: {},
331         answer: {
332             type:  [''],
333             info: {
334                 'gpgme': 'string',
335                 'info': 'object'
336             }
337         }
338     },
339
340     createkey: {
341         pinentry: true,
342         required: {
343             userid: {
344                 allowed: ['string']
345             }
346         },
347         optional: {
348             algo: {
349                 allowed: ['string']
350             },
351             expires: {
352                 allowed: ['number'],
353             }
354         },
355         answer: {
356             type: [''],
357             info: { 'fingerprint': 'string' }
358         }
359     },
360
361     verify: {
362         required: {
363             data: {
364                 allowed: ['string']
365             }
366         },
367         optional: {
368             'protocol': {
369                 allowed: ['string'],
370                 allowed_data: ['cms', 'openpgp']
371             },
372             'signature': {
373                 allowed: ['string']
374             },
375             'base64':{
376                 allowed: ['boolean']
377             }
378         },
379         answer: {
380             type: ['plaintext'],
381             payload:{
382                 'data': 'string'
383             },
384             info: {
385                 'base64':'boolean',
386                 'info': 'object'
387                 // info.file_name: Optional string of the plaintext file name.
388                 // info.is_mime: Boolean if the messages claims it is MIME.
389                 // info.signatures: Array of signatures
390             }
391         }
392     },
393
394     config_opt: {
395         required: {
396             'component':{
397                 allowed: ['string'],
398                 // allowed_data: ['gpg'] // TODO check all available
399             },
400             'option': {
401                 allowed: ['string'],
402                 // allowed_data: ['default-key'] // TODO check all available
403             }
404         },
405         optional: {},
406         answer: {
407             type: [],
408             info: {
409                 'option': 'object'
410             }
411         }
412     }
413 };