source: filezilla/trunk/fuentes/src/putty/cmdgen.c @ 3185

Last change on this file since 3185 was 3185, checked in by jrpelegrina, 3 years ago

Update new version: 3.15.02

File size: 6.8 KB
Line 
1/*
2 * fzputtygen, based on puttygen.
3 */
4
5#define PUTTY_DO_GLOBALS
6
7#include <stdio.h>
8#include <stdlib.h>
9#include <ctype.h>
10#include <limits.h>
11#include <assert.h>
12#include <time.h>
13
14#include "putty.h"
15#include "ssh.h"
16
17void modalfatalbox(const char *fmt, ...)
18{
19    va_list ap;
20    char* str;
21
22    va_start(ap, fmt);
23    str = dupvprintf(fmt, ap);
24    va_end(ap);
25    fzprintf(sftpError, "Fatal error: %s", str);
26    sfree(str);
27
28    cleanup_exit(1);
29}
30
31void nonfatal(const char *fmt, ...)
32{
33    va_list ap;
34    char* str;
35
36    va_start(ap, fmt);
37    str = dupvprintf(fmt, ap);
38    va_end(ap);
39    fzprintf(sftpError, "Error: %s", str);
40    sfree(str);
41}
42
43/*
44 * Stubs to let everything else link sensibly.
45 */
46void log_eventlog(void *handle, const char *event)
47{
48}
49char *x_get_default(const char *key)
50{
51    return NULL;
52}
53void sk_cleanup(void)
54{
55}
56
57int main(int argc, char **argv)
58{
59    Filename *infilename = NULL;
60    int intype = SSH_KEYTYPE_UNOPENABLE;
61    int encrypted = 0;
62    char* origcomment = 0;
63    char* line = 0;
64    char* passphrase = 0;
65    struct ssh2_userkey *ssh2key = NULL;
66    char* fingerprint = 0;
67
68    printf("fzputtygen\n");
69    printf("Copyright (C) 2008-2016  Tim Kosse\n");
70    printf("Based on PuTTY's puttygen\n");
71    printf("Copyright (C) 1997-2015  Simon Tatham and the PuTTY team\n");
72    printf("Converts private SSH keys into PuTTY's format.\n");
73    printf("This program is used by FileZilla and not intended to be used directly.\n");
74    printf("Use the puttygen tool from PuTTY for a human-usable tool.\n");
75    printf("\n");
76    fflush(stdout);
77
78    while (1) {
79        sfree(line);
80
81        line = fgetline(stdin);
82        if (!line || !*line || *line == '\n')
83            break;
84
85        line[strlen(line) - 1] = 0;
86        char* cmd = line, *args = line;
87       
88        while (*args) {
89            if (*args == ' ') {
90                *(args++) = 0;
91                break;
92            }
93            args++;
94        }
95        if (!*args)
96            args = 0;
97
98        if (!strcmp(cmd, "file")) {
99            char const* ret = NULL;
100            if (ssh2key) {
101                ssh2key->alg->freekey(ssh2key->data);
102                sfree(ssh2key);
103                ssh2key = 0;
104            }
105            sfree(passphrase);
106            passphrase = 0;
107            sfree(fingerprint);
108            fingerprint = 0;
109           
110            if (!args) {
111                fzprintf(sftpError, "No argument given");
112                continue;
113            }
114
115            if (infilename) {
116                filename_free(infilename);
117            }
118            infilename = filename_from_str(args);
119
120            intype = key_type(infilename);
121            switch (intype)
122            {
123            case SSH_KEYTYPE_SSH1:
124                ret = "incompatible";
125                intype = SSH_KEYTYPE_UNOPENABLE;
126                break;
127            case SSH_KEYTYPE_SSH2:
128                ret = "ok";
129                encrypted = ssh2_userkey_encrypted(infilename, &origcomment);
130                break;
131            case SSH_KEYTYPE_UNKNOWN:
132            case SSH_KEYTYPE_UNOPENABLE:
133            default:
134                ret = "error";
135                intype = SSH_KEYTYPE_UNOPENABLE;
136                break;
137            case SSH_KEYTYPE_OPENSSH_PEM:
138            case SSH_KEYTYPE_OPENSSH_NEW:
139            case SSH_KEYTYPE_SSHCOM:
140                encrypted = import_encrypted(infilename, intype, &origcomment);
141                ret = encrypted ? "convertible" : "ok";
142                break;
143            }
144            fzprintf(sftpReply, "%s", ret);
145        }
146        else if (!strcmp(cmd, "encrypted")) {
147            if (intype == SSH_KEYTYPE_UNOPENABLE) {
148                fzprintf(sftpError, "No key file opened");
149                continue;
150            }
151           
152            fzprintf(sftpReply, "%d", encrypted ? 1 : 0);
153        }
154        else if (!strcmp(cmd, "comment")) {
155            if (intype == SSH_KEYTYPE_UNOPENABLE) {
156                fzprintf(sftpError, "No key file opened");
157                continue;
158            }
159            if (ssh2key && ssh2key->comment) {
160                fzprintf(sftpReply, "%s", ssh2key->comment);
161            }
162            else if (origcomment)
163                fzprintf(sftpReply, "%s", origcomment);
164            else
165                fzprintf(sftpReply, "");
166        }
167        else if (!strcmp(cmd, "password")) {
168            const char* error = NULL;
169
170            if (!args) {
171                fzprintf(sftpError, "No argument given");
172                continue;
173            }
174
175            if (intype == SSH_KEYTYPE_UNOPENABLE) {
176                fzprintf(sftpError, "No key file opened");
177                continue;
178            }
179
180            if (!encrypted) {
181                fzprintf(sftpError, "File is not encrypted");
182                continue;
183            }
184
185            if (ssh2key) {
186                fzprintf(sftpError, "Already opened file");
187                continue;
188            }
189
190            sfree(passphrase);
191            passphrase = strdup(args);
192
193            switch (intype) {
194                case SSH_KEYTYPE_SSH2:
195                    ssh2key = ssh2_load_userkey(infilename, passphrase, &error);
196                    break;
197                case SSH_KEYTYPE_OPENSSH_PEM:
198                case SSH_KEYTYPE_OPENSSH_NEW:
199                case SSH_KEYTYPE_SSHCOM:
200                    ssh2key = import_ssh2(infilename, intype, passphrase, &error);
201                    break;
202                default:
203                    break;
204            }
205            if (ssh2key == SSH2_WRONG_PASSPHRASE) {
206                error = "wrong passphrase";
207                ssh2key = 0;
208            }
209            if (ssh2key) {
210                error = NULL;
211            }
212            else if (!error) {
213                error = "unknown error";
214            }
215
216            if (error)
217                fzprintf(sftpError, "Error loading file: %s", error);
218            else
219                fzprintf(sftpReply, "");
220        }
221        else if (!strcmp(cmd, "fingerprint")) {
222            const char* error = 0;
223            void* blob = NULL;
224            int bloblen = 0;
225
226            if (!fingerprint) {
227                if (ssh2key) {
228                    fingerprint = ssh2_fingerprint(ssh2key->alg, ssh2key->data);
229                }
230                else {
231                    switch (intype) {
232                         case SSH_KEYTYPE_SSH2:
233                        {
234                            void* ssh2blob;
235                            int bloblen = 0;
236                            char* comment = NULL;
237
238                            ssh2blob = ssh2_userkey_loadpub(infilename, 0, &bloblen, &comment, &error);
239                            if (ssh2blob) {
240                                fingerprint = ssh2_fingerprint_blob(ssh2blob, bloblen);
241                                sfree(ssh2blob);
242                            }
243                            else if (!error) {
244                                error = "unknown error";
245                            }
246
247                            if (comment) {
248                                sfree(origcomment);
249                                origcomment = comment;
250                            }
251                            break;
252                        }
253                        case SSH_KEYTYPE_OPENSSH_PEM:
254                        case SSH_KEYTYPE_OPENSSH_NEW:
255                        case SSH_KEYTYPE_SSHCOM:
256                            ssh2key = import_ssh2(infilename, intype, "", &error);
257                            if (ssh2key) {
258                                if (ssh2key != SSH2_WRONG_PASSPHRASE) {
259                                    error = NULL;
260                                    fingerprint = ssh2_fingerprint(ssh2key->alg, ssh2key->data);
261                                }
262                                else {
263                                    ssh2key = NULL;
264                                    error = "wrong passphrase";
265                                }
266                            }
267                            else if (!error)
268                                error = "unknown error";
269                            break;
270                        default:
271                            error = "No file loaded";
272                            break;
273                    }
274                }
275            }
276
277            if (!fingerprint && !error) {
278                error = "Could not get fingerprint";
279            }
280
281            if (error)
282                fzprintf(sftpError, "Error loading file: %s", error);
283            else
284                fzprintf(sftpReply, "%s", fingerprint);
285        }
286        else if (!strcmp(cmd, "write")) {
287            Filename* outfilename;
288
289            int ret;
290            if (!args) {
291                fzprintf(sftpError, "No argument given");
292                continue;
293            }
294
295            if (!ssh2key) {
296                fzprintf(sftpError, "No key loaded");
297                continue;
298            }
299
300            outfilename = filename_from_str(args);
301
302            ret = ssh2_save_userkey(outfilename, ssh2key, passphrase);
303             if (!ret) {
304                fzprintf(sftpError, "Unable to save SSH-2 private key");
305                continue;
306            }
307
308            filename_free(outfilename);
309
310            fzprintf(sftpReply, "");
311        }
312        else
313                fzprintf(sftpError, "Unknown command");
314    }
315
316    if (infilename) {
317        filename_free(infilename);
318    }
319    sfree(line);
320    sfree(passphrase);
321    if (ssh2key) {
322        ssh2key->alg->freekey(ssh2key->data);
323        sfree(ssh2key);
324    }
325    sfree(fingerprint);
326    sfree(origcomment);
327
328    return 0;
329}
Note: See TracBrowser for help on using the repository browser.