e4f9bd22676a1b4b0dd7028b6321bf3dc468feec
[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
21  /**
22   * Definition of the possible interactions with gpgme-json.
23   * operation: <Object>
24       required: Array<Object>
25             <String> name The name of the property
26             allowed: Array of allowed types. Currently accepted values:
27                 ['number', 'string', 'boolean', 'Uint8Array']
28             array_allowed: Boolean. If the value can be an array of the above
29             allowed_data: <Array> If present, restricts to the given value
30       optional: Array<Object>
31             see 'required', with these parameters not being mandatory for a
32             complete message
33       pinentry: boolean If a pinentry dialog is expected, and a timeout of
34                 5000 ms would be too short
35       answer: <Object>
36           type: <String< The content type of answer expected
37           data: Array<String> The payload property of the answer. May be
38                 partial and in need of concatenation
39           params: Array<String> Information that do not change throughout
40                 the message
41           infos: Array<*> arbitrary information that may result in a list
42       }
43   }
44   */
45
46 export const permittedOperations = {
47     encrypt: {
48         pinentry: true, //TODO only with signing_keys
49         required: {
50             'keys': {
51                 allowed: ['string'],
52                 array_allowed: true
53             },
54             'data': {
55                 allowed: ['string']
56             }
57         },
58         optional: {
59             'protocol': {
60                 allowed: ['string'],
61                 allowed_data: ['cms', 'openpgp']
62             },
63             'signing_keys': {
64                 allowed: ['string'],
65                 array_allowed: true
66             },
67             'chunksize': {
68                     allowed: ['number']
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: ['data'],
102             params: ['base64'],
103             infos: []
104         }
105     },
106
107     decrypt: {
108         pinentry: true,
109         required: {
110             'data': {
111                 allowed: ['string']
112             }
113         },
114         optional: {
115             'protocol': {
116                 allowed: ['string'],
117                 allowed_data: ['cms', 'openpgp']
118             },
119             'chunksize': {
120                 allowed: ['number'],
121             },
122             'base64': {
123                 allowed: ['boolean']
124             }
125         },
126         answer: {
127             type: ['plaintext'],
128             data: ['data'],
129             params: ['base64', 'mime'],
130             infos: ['signatures']
131         }
132     },
133
134     sign: {
135         pinentry: true,
136         required: {
137             'data': {
138                 allowed: ['string']},
139             'keys': {
140                 allowed: ['string'],
141                 array_allowed: true
142             }
143         },
144         optional: {
145             'protocol': {
146                 allowed: ['string'],
147                 allowed_data: ['cms', 'openpgp']
148             },
149             'chunksize': {
150                 allowed: ['number'],
151             },
152             'sender': {
153                 allowed: ['string'],
154             },
155             'mode': {
156                 allowed: ['string'],
157                 allowed_data: ['detached', 'clearsign'] // TODO 'opaque' not used
158             },
159             'base64': {
160                 allowed: ['boolean']
161             },
162             'armor': {
163                 allowed: ['boolean']
164             },
165         },
166         answer: {
167             type: ['signature', 'ciphertext'],
168             data: ['data'], // Unless armor mode is used a Base64 encoded binary
169                             // signature.  In armor mode a string with an armored
170                             // OpenPGP or a PEM message.
171             params: ['base64']
172         }
173     },
174
175     keylist:{
176         required: {},
177         optional: {
178             'protocol': {
179                 allowed: ['string'],
180                 allowed_data: ['cms', 'openpgp']
181             },
182             'chunksize': {
183                 allowed: ['number'],
184             },
185             // note: For the meaning of the flags, refer to
186             // https://www.gnupg.org/documentation/manuals/gpgme/Key-Listing-Mode.html
187             'secret': {
188                 allowed: ['boolean']
189             },
190             'extern': {
191                 allowed: ['boolean']
192             },
193             'local':{
194                 allowed: ['boolean']
195             },
196             'sigs':{
197                 allowed: ['boolean']
198             },
199             'notations':{
200                 allowed: ['boolean']
201             },
202             'tofu': {
203                 allowed: ['boolean']
204             },
205             'ephemeral': {
206                 allowed: ['boolean']
207             },
208             'validate': {
209                 allowed: ['boolean']
210             },
211             'keys': {
212                 allowed: ['string'],
213                 array_allowed: true
214             }
215         },
216         answer: {
217             type: ['keys'],
218             data: [],
219             params: ['base64'],
220             infos: ['keys']
221         }
222     },
223
224     export: {
225         required: {},
226         optional: {
227             'protocol': {
228                 allowed: ['string'],
229                 allowed_data: ['cms', 'openpgp']
230             },
231             'chunksize': {
232                 allowed: ['number'],
233             },
234             'keys': {
235                 allowed: ['string'],
236                 array_allowed: true
237             },
238             'armor': {
239                 allowed: ['boolean']
240             },
241             'extern': {
242                 allowed: ['boolean']
243             },
244             'minimal': {
245                 allowed: ['boolean']
246             },
247             'raw': {
248                 allowed: ['boolean']
249             },
250             'pkcs12':{
251                 allowed: ['boolean']
252             }
253             // secret: not yet implemented
254         },
255         answer: {
256             type: ['keys'],
257             data: ['data'],
258             params: ['base64']
259         }
260     },
261
262     import: {
263         required: {
264             'data': {
265                 allowed: ['string']
266             }
267         },
268         optional: {
269             'protocol': {
270                 allowed: ['string'],
271                 allowed_data: ['cms', 'openpgp']
272             },
273             'base64': {
274                 allowed: ['boolean']
275             },
276         },
277         answer: {
278             infos: ['result'],
279             type: [],
280             data: [],
281             params: []
282         }
283     },
284
285     delete: {
286         pinentry: true,
287         required:{
288             'key': {
289                 allowed: ['string']
290             }
291         },
292         optional: {
293             'protocol': {
294                 allowed: ['string'],
295                 allowed_data: ['cms', 'openpgp']
296             },
297             // 'secret': { not yet implemented
298             //     allowed: ['boolean']
299             // }
300
301         },
302         answer: {
303             data: [],
304             params:['success'],
305             infos: []
306         }
307     },
308     /**
309      *TBD get armored secret different treatment from keyinfo!
310      * TBD key modification?
311
312      */
313
314     version: {
315         required: {},
316         optional: {},
317         answer: {
318             type:  [''],
319             data: ['gpgme'],
320             infos: ['info'],
321             params:[]
322         }
323     }
324 }