js: code cleanup (eslint)
[gpgme.git] / lang / js / src / Keyring.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 import {createMessage} from './Message';
26 import {createKey} from './Key';
27 import { isFingerprint } from './Helpers';
28 import { gpgme_error } from './Errors';
29
30 export class GPGME_Keyring {
31     constructor(){
32     }
33
34     /**
35      * @param {String} pattern (optional) pattern A pattern to search for,
36      * in userIds or KeyIds
37      * @param {Boolean} prepare_sync (optional, default true) if set to true,
38      * Key.armor and Key.hasSecret will be called, so they can be used
39      * inmediately. This allows for full synchronous use. If set to false,
40      * these will initially only be available as Promises in getArmor() and
41      * getHasSecret()
42      * @returns {Promise.<Array<GPGME_Key>>}
43      *
44      */
45     getKeys(pattern, prepare_sync){
46         return new Promise(function(resolve, reject) {
47             let msg = createMessage('keylist');
48             if (pattern !== undefined){
49                 msg.setParameter('keys', pattern);
50             }
51             msg.setParameter('sigs', true);
52             msg.post().then(function(result){
53                 let resultset = [];
54                 let promises = [];
55                 if (result.keys.length === 0){
56                     resolve([]);
57                 } else {
58                     for (let i=0; i< result.keys.length; i++){
59                         let k = createKey(result.keys[i].fingerprint);
60                         k.setKeyData(result.keys[i]);
61                         if (prepare_sync === true){
62                             promises.push(k.getArmor());
63                             promises.push(k.getHasSecret());
64                         }
65                         resultset.push(k);
66                     }
67                     if (promises.length > 0) {
68                         Promise.all(promises).then(function() {
69                             resolve(resultset);
70                         }, function(error){
71                             reject(error);
72                         });
73                     } else {
74                         resolve(resultset);
75                     }
76                 }
77             });
78         });
79     }
80
81     /**
82      * Fetches the armored public Key blocks for all Keys matchin the pattern
83      * (if no pattern is given, fetches all known to gnupg)
84      * @param {String|Array<String>} pattern (optional)
85      * @returns {Promise<String>} Armored Key blocks
86      */
87     getKeysArmored(pattern) {
88         return new Promise(function(resolve, reject) {
89             let msg = createMessage('export');
90             msg.setParameter('armor', true);
91             if (pattern !== undefined){
92                 msg.setParameter('keys', pattern);
93             }
94             msg.post().then(function(result){
95                 resolve(result.data);
96             }, function(error){
97                 reject(error);
98             });
99         });
100     }
101
102     // getDefaultKey() Big TODO
103
104     /**
105      *
106      * @param {String} armored Armored Key block of the Kex(s) to be imported
107      * into gnupg
108      * @param {Boolean} prepare_sync prepare the keys for synched use
109      * (see getKeys()).
110      * @returns {Promise<Array<Object>>} An array of objects for the Keys
111      * considered:
112     *       Key.key <Object>: The key itself as a GPGME_Key
113      *      Key.status <String>:
114      *          'nochange' if the Key was not changed,
115      *          'newkey' if the Key was imported in gpg, and did not exist
116      *              previously,
117      *          'change' if the key existed, but details were updated. For
118      *              details, Key.changes is available.
119      *          Key.changes.userId: <Boolean> userIds changed
120      *          Key.changes.signature: <Boolean> signatures changed
121      *          Key.changes.subkey: <Boolean> subkeys changed
122      * // TODO: not yet implemented: Information about Keys that failed
123      *          (e.g. malformed Keys, secretKeys are not accepted)
124      */
125     importKey(armored, prepare_sync) {
126         if (!armored || typeof(armored) !== 'string'){
127             return Promise.reject(gpgme_error('PARAM_WRONG'));
128         }
129         let me = this;
130         return new Promise(function(resolve, reject){
131             let msg = createMessage('import');
132             msg.setParameter('data', armored);
133             msg.post().then(function(response){
134                 let infos = {};
135                 let fprs = [];
136                 for (let res=0; res < response.result[0].imports.length; res++){
137                     let result = response.result[0].imports[res];
138                     let status = '';
139                     if (result.status === 0){
140                         status = 'nochange';
141                     } else if ((result.status & 1) === 1){
142                         status = 'newkey';
143                     } else {
144                         status = 'change';
145                     }
146                     let changes = {};
147                     changes.userId = (result.status & 2) === 2;
148                     changes.signature = (result.status & 4) === 4;
149                     changes.subkey = (result.status & 8) === 8;
150                     //16 new secret key: not implemented
151
152                     fprs.push(result.fingerprint);
153                     infos[result.fingerprint] = {
154                         changes: changes,
155                         status: status
156                     };
157                 }
158                 let resultset = [];
159                 if (prepare_sync === true){
160                     me.getKeys(fprs, true).then(function(result){
161                         for (let i=0; i < result.length; i++) {
162                             resultset.push({
163                                 key: result[i],
164                                 changes: infos[result[i].fingerprint].changes,
165                                 status: infos[result[i].fingerprint].status
166                             });
167                         }
168                         resolve(resultset);
169                     }, function(error){
170                         reject(error);
171                     });
172                 } else {
173                     for (let i=0; i < fprs.length; i++) {
174                         resultset.push({
175                             key: createKey(fprs[i]),
176                             changes: infos[fprs[i]].changes,
177                             status: infos[fprs[i]].status
178                         });
179                     }
180                     resolve(resultset);
181                 }
182
183             }, function(error){
184                 reject(error);
185             });
186
187
188         });
189
190
191     }
192
193     deleteKey(fingerprint){
194         if (isFingerprint(fingerprint) === true) {
195             let key = createKey(fingerprint);
196             key.delete();
197         }
198     }
199
200     // generateKey
201 }