0b9c891f7acba9e25fbea7b03582e95c87278db9
[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 <http://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.data key-value combinations of expected properties
46  * of an answer and their type ('boolean', 'string', object)
47   @const
48 */
49 export const permittedOperations = {
50     encrypt: {
51         pinentry: true, //TODO only with signing_keys
52         required: {
53             'keys': {
54                 allowed: ['string'],
55                 array_allowed: true
56             },
57             'data': {
58                 allowed: ['string']
59             }
60         },
61         optional: {
62             'protocol': {
63                 allowed: ['string'],
64                 allowed_data: ['cms', 'openpgp']
65             },
66             'signing_keys': {
67                 allowed: ['string'],
68                 array_allowed: true
69             },
70             'base64': {
71                 allowed: ['boolean']
72             },
73             'mime': {
74                 allowed: ['boolean']
75             },
76             'armor': {
77                 allowed: ['boolean']
78             },
79             'always-trust': {
80                 allowed: ['boolean']
81             },
82             'no-encrypt-to': {
83                 allowed: ['string'],
84                 array_allowed: true
85             },
86             'no-compress': {
87                 allowed: ['boolean']
88             },
89             'throw-keyids': {
90                 allowed: ['boolean']
91             },
92             'want-address': {
93                 allowed: ['boolean']
94             },
95             'wrap': {
96                 allowed: ['boolean']
97             }
98         },
99         answer: {
100             type: ['ciphertext'],
101             data: {
102                 'data': 'string',
103                 'base64':'boolean'
104             }
105         }
106     },
107
108     decrypt: {
109         pinentry: true,
110         required: {
111             'data': {
112                 allowed: ['string']
113             }
114         },
115         optional: {
116             'protocol': {
117                 allowed: ['string'],
118                 allowed_data: ['cms', 'openpgp']
119             },
120             'base64': {
121                 allowed: ['boolean']
122             }
123         },
124         answer: {
125             type: ['plaintext'],
126             data: {
127                 'data': 'string',
128                 'base64': 'boolean',
129                 'mime': 'boolean',
130                 'signatures': 'object'
131             }
132         }
133     },
134
135     sign: {
136         pinentry: true,
137         required: {
138             'data': {
139                 allowed: ['string']},
140             'keys': {
141                 allowed: ['string'],
142                 array_allowed: true
143             }
144         },
145         optional: {
146             'protocol': {
147                 allowed: ['string'],
148                 allowed_data: ['cms', 'openpgp']
149             },
150             'sender': {
151                 allowed: ['string'],
152             },
153             'mode': {
154                 allowed: ['string'],
155                 allowed_data: ['detached', 'clearsign']
156                 // TODO 'opaque' is not used, but available on native app
157             },
158             'base64': {
159                 allowed: ['boolean']
160             },
161             'armor': {
162                 allowed: ['boolean']
163             },
164         },
165         answer: {
166             type: ['signature', 'ciphertext'],
167             data: {
168                 'data': 'string',
169                 'base64':'boolean'
170             }
171
172         }
173     },
174
175     // note: For the meaning of the optional keylist flags, refer to
176     // https://www.gnupg.org/documentation/manuals/gpgme/Key-Listing-Mode.html
177     keylist:{
178         required: {},
179
180         optional: {
181             'protocol': {
182                 allowed: ['string'],
183                 allowed_data: ['cms', 'openpgp']
184             },
185             'secret': {
186                 allowed: ['boolean']
187             },
188             'extern': {
189                 allowed: ['boolean']
190             },
191             'local':{
192                 allowed: ['boolean']
193             },
194             'locate': {
195                 allowed: ['boolean']
196             },
197             'sigs':{
198                 allowed: ['boolean']
199             },
200             'notations':{
201                 allowed: ['boolean']
202             },
203             'tofu': {
204                 allowed: ['boolean']
205             },
206             'ephemeral': {
207                 allowed: ['boolean']
208             },
209             'validate': {
210                 allowed: ['boolean']
211             },
212             'keys': {
213                 allowed: ['string'],
214                 array_allowed: true
215             }
216         },
217         answer: {
218             type: ['keys'],
219             data: {
220                 'base64': 'boolean',
221                 'keys': 'object'
222             }
223         }
224     },
225
226     export: {
227         required: {},
228         optional: {
229             'protocol': {
230                 allowed: ['string'],
231                 allowed_data: ['cms', 'openpgp']
232             },
233             'keys': {
234                 allowed: ['string'],
235                 array_allowed: true
236             },
237             'armor': {
238                 allowed: ['boolean']
239             },
240             'extern': {
241                 allowed: ['boolean']
242             },
243             'minimal': {
244                 allowed: ['boolean']
245             },
246             'raw': {
247                 allowed: ['boolean']
248             },
249             'pkcs12':{
250                 allowed: ['boolean']
251             }
252             // secret: not yet implemented
253         },
254         answer: {
255             type: ['keys'],
256             data: {
257                 'data': 'string',
258                 'base64': 'boolean'
259             }
260         }
261     },
262
263     import: {
264         required: {
265             'data': {
266                 allowed: ['string']
267             }
268         },
269         optional: {
270             'protocol': {
271                 allowed: ['string'],
272                 allowed_data: ['cms', 'openpgp']
273             },
274             'base64': {
275                 allowed: ['boolean']
276             },
277         },
278         answer: {
279             type: [],
280             data: {
281                 'result': 'object'
282             }
283         }
284     },
285
286     delete: {
287         pinentry: true,
288         required:{
289             'key': {
290                 allowed: ['string']
291             }
292         },
293         optional: {
294             'protocol': {
295                 allowed: ['string'],
296                 allowed_data: ['cms', 'openpgp']
297             },
298             // 'secret': { not implemented
299             //     allowed: ['boolean']
300             // }
301
302         },
303         answer: {
304             data: {
305                 'success': 'boolean'
306             }
307         }
308     },
309
310     version: {
311         required: {},
312         optional: {},
313         answer: {
314             type:  [''],
315             data: {
316                 'gpgme': 'string',
317                 'info': 'object'
318             }
319         }
320     },
321
322     createkey: {
323         pinentry: true,
324         required: {
325             userid: {
326                 allowed: ['string']
327             }
328         },
329         optional: {
330             algo: {
331                 allowed: ['string']
332             },
333             expires: {
334                 allowed: ['number'],
335             }
336         },
337         answer: {
338             type: [''],
339             data: {'fingerprint': 'string'}
340         }
341     },
342
343     verify: {
344         required: {
345             data: {
346                 allowed: ['string']
347             }
348         },
349         optional: {
350             'protocol': {
351                 allowed: ['string'],
352                 allowed_data: ['cms', 'openpgp']
353             },
354             'signature': {
355                 allowed: ['string']
356             },
357             'base64':{
358                 allowed: ['boolean']
359             }
360         },
361         answer: {
362             type: ['plaintext'],
363             data:{
364                 data: 'string',
365                 base64:'boolean',
366                 info: 'object'
367                 // file_name: Optional string of the plaintext file name.
368                 //  is_mime: Boolean if the messages claims it is MIME.
369                 // signatures: Array of signatures
370             }
371         }
372     },
373
374     config_opt: {
375         required: {
376             'component':{
377                 allowed: ['string'],
378                 // allowed_data: ['gpg'] // TODO check all available
379             },
380             'option': {
381                 allowed: ['string'],
382                 // allowed_data: ['default-key'] // TODO check all available
383             }
384         },
385         optional: {},
386         answer: {
387             type: [],
388             data: {
389                 option: 'object'
390             }
391         }
392     }
393
394     /**
395      * TBD handling of secrets
396      * TBD key modification?
397      */
398
399 };