src/formhist/formhist.c

   1 /* Implementation of a login manager for HTML forms */
   2
   3 #ifdef HAVE_CONFIG_H
   4 #include "config.h"
   5 #endif
   6
   7 #include <string.h>
   8
   9 #include "elinks.h"
  10
  11 #include "bfu/dialog.h"
  12 #include "config/home.h"
  13 #include "document/forms.h"
  14 #include "formhist/dialogs.h"
  15 #include "formhist/formhist.h"
  16 #include "intl/gettext/libintl.h"
  17 #include "main/module.h"
  18 #include "main/object.h"
  19 #include "session/session.h"
  20 #include "terminal/window.h"
  21 #include "util/base64.h"
  22 #include "util/file.h"
  23 #include "util/lists.h"
  24 #include "util/secsave.h"
  25 #include "util/string.h"
  26 #include "viewer/text/form.h"
  27
  28 #define FORMS_HISTORY_FILENAME          "formhist"
  29
  30
  31 /* TODO: Remember multiple login for the same form.
  32  * TODO: Password manager GUI (here?) (in dialogs.c, of course --pasky). */
  33
  34
  35 static union option_info forms_history_options[] = {
  36         INIT_OPT_BOOL("document.browse.forms", N_("Show form history dialog"),
  37                 "show_formhist", 0, 0,
  38                 N_("Ask if a login form should be saved to file or not. "
  39                 "This option only disables the dialog, already saved login "
  40                 "forms are unaffected.")),
  41
  42         NULL_OPTION_INFO,
  43 };
  44
  45 INIT_LIST_OF(struct formhist_data, saved_forms);
  46
  47 static struct formhist_data *
  48 new_formhist_item(unsigned char *url)
  49 {
  50         struct formhist_data *form;
  51         int url_len = strlen(url);
  52
  53         form = mem_calloc(1, sizeof(*form) + url_len);
  54         if (!form) return NULL;
  55
  56         memcpy(form->url, url, url_len);
  57         form->submit = mem_alloc(sizeof(*form->submit));
  58         if (!form->submit) { mem_free(form); return NULL; }
  59
  60         object_nolock(form, "formhist");
  61         init_list(*form->submit);
  62         form->box_item = add_listbox_leaf(&formhist_browser, NULL, form);
  63         if (!form->box_item) {
  64                 mem_free(form->submit);
  65                 mem_free(form);
  66                 return NULL;
  67         }
  68
  69         return form;
  70 }
  71
  72 static void
  73 done_formhist_item(struct formhist_data *form)
  74 {
  75         done_listbox_item(&formhist_browser, form->box_item);
  76         done_submitted_value_list(form->submit);
  77         mem_free(form->submit);
  78         mem_free(form);
  79 }
  80
  81 void
  82 delete_formhist_item(struct formhist_data *form)
  83 {
  84         del_from_list(form);
  85         done_formhist_item(form);
  86 }
  87
  88 static int loaded = 0;
  89
  90 int
  91 load_formhist_from_file(void)
  92 {
  93         struct formhist_data *form;
  94         unsigned char tmp[MAX_STR_LEN];
  95         unsigned char *file;
  96         FILE *f;
  97
  98         if (loaded) return 1;
  99
 100         if (!elinks_home) return 0;
 101
 102         file = straconcat(elinks_home, FORMS_HISTORY_FILENAME,
 103                           (unsigned char *) NULL);
 104         if (!file) return 0;
 105
 106         f = fopen(file, "rb");
 107         mem_free(file);
 108         if (!f) return 0;
 109
 110         while (fgets(tmp, MAX_STR_LEN, f)) {
 111                 unsigned char *p;
 112                 int dontsave = 0;
 113
 114                 if (tmp[0] == '\n' && !tmp[1]) continue;
 115
 116                 p = strchr(tmp, '\t');
 117                 if (p) {
 118                         *p = '\0';
 119                         ++p;
 120                         if (!strcmp(tmp, "dontsave"))
 121                                 dontsave = 1;
 122                 } else {
 123                         /* Compat. with older file formats. Remove it at some
 124                          * time. --Zas */
 125                         if (!strncmp(tmp, "dontsave,", 9)) {
 126                                 dontsave = 1;
 127                                 p = tmp + 9;
 128                         } else {
 129                                 p = tmp;
 130                         }
 131                 }
 132
 133                 /* URL */
 134                 p[strlen(p) - 1] = '\0';
 135
 136                 form = new_formhist_item(p);
 137                 if (!form) continue;
 138                 if (dontsave) form->dontsave = 1;
 139
 140                 /* Fields type, name, value */
 141                 while (fgets(tmp, MAX_STR_LEN, f)) {
 142                         struct submitted_value *sv;
 143                         unsigned char *type, *name, *value;
 144                         unsigned char *enc_value;
 145                         enum form_type ftype;
 146                         int ret;
 147
 148                         if (tmp[0] == '\n' && !tmp[1]) break;
 149
 150                         /* Type */
 151                         type = tmp;
 152                         p = strchr(type, '\t');
 153                         if (!p) goto fail;
 154                         *p = '\0';
 155
 156                         /* Name */
 157                         name = ++p;
 158                         p = strchr(name, '\t');
 159                         if (!p) {
 160                                 /* Compatibility with previous file formats.
 161                                  * REMOVE AT SOME TIME --Zas */
 162                                 value = name;
 163                                 name = type;
 164
 165                                 if (*name == '*') {
 166                                         name++;
 167                                         type = "password";
 168                                 } else {
 169                                         type = "text";
 170                                 }
 171
 172                                 goto cont;
 173                         }
 174                         *p = '\0';
 175
 176                         /* Value */
 177                         value = ++p;
 178 cont:
 179                         p = strchr(value, '\n');
 180                         if (!p) goto fail;
 181                         *p = '\0';
 182
 183                         ret = str2form_type(type);
 184                         if (ret == -1) goto fail;
 185                         ftype = ret;
 186
 187                         if (form->dontsave) continue;
 188
 189                         enc_value = *value ? base64_decode(value)
 190                                            : stracpy(value);
 191                         if (!enc_value) goto fail;
 192
 193                         sv = init_submitted_value(name, enc_value,
 194                                                  ftype, NULL, 0);
 195
 196                         mem_free(enc_value);
 197                         if (!sv) goto fail;
 198
 199                         add_to_list(*form->submit, sv);
 200                 }
 201
 202                 add_to_list(saved_forms, form);
 203         }
 204
 205         fclose(f);
 206         loaded = 1;
 207
 208         return 1;
 209
 210 fail:
 211         done_formhist_item(form);
 212         return 0;
 213 }
 214
 215 int
 216 save_formhist_to_file(void)
 217 {
 218         struct secure_save_info *ssi;
 219         unsigned char *file;
 220         struct formhist_data *form;
 221         int r;
 222
 223         if (!elinks_home || get_cmd_opt_bool("anonymous"))
 224                 return 0;
 225
 226         file = straconcat(elinks_home, FORMS_HISTORY_FILENAME,
 227                           (unsigned char *) NULL);
 228         if (!file) return 0;
 229
 230         ssi = secure_open(file);
 231         mem_free(file);
 232         if (!ssi) return 0;
 233
 234         /* Write the list to password file ($ELINKS_HOME/formhist) */
 235
 236         foreach (form, saved_forms) {
 237                 struct submitted_value *sv;
 238
 239                 if (form->dontsave) {
 240                         secure_fprintf(ssi, "dontsave\t%s\n\n", form->url);
 241                         continue;
 242                 }
 243
 244                 secure_fprintf(ssi, "%s\n", form->url);
 245
 246                 foreach (sv, *form->submit) {
 247                         unsigned char *encvalue;
 248
 249                         if (sv->value && *sv->value) {
 250                                 /* Obfuscate the value. If we do
 251                                  * $ cat ~/.elinks/formhist
 252                                  * we don't want someone behind our back to read our
 253                                  * password (androids don't count). */
 254                                 encvalue = base64_encode(sv->value);
 255                         } else {
 256                                 encvalue = stracpy("");
 257                         }
 258
 259                         if (!encvalue) return 0;
 260                         /* Format is : type[TAB]name[TAB]value[CR] */
 261                         secure_fprintf(ssi, "%s\t%s\t%s\n", form_type2str(sv->type),
 262                                        sv->name, encvalue);
 263
 264                         mem_free(encvalue);
 265                 }
 266
 267                 secure_fputc(ssi, '\n');
 268         }
 269
 270         r = secure_close(ssi);
 271         if (r == 0) loaded = 1;
 272
 273         return r;
 274 }
 275
 276 /* Check whether the form (chain of @submit submitted_values at @url document)
 277  * is already present in the form history. */
 278 static int
 279 form_exists(struct formhist_data *form1)
 280 {
 281         struct formhist_data *form;
 282
 283         if (!load_formhist_from_file()) return 0;
 284
 285         foreach (form, saved_forms) {
 286                 int count = 0;
 287                 int exact = 0;
 288                 struct submitted_value *sv;
 289
 290                 if (strcmp(form->url, form1->url)) continue;
 291                 if (form->dontsave) return 1;
 292
 293                 /* Iterate through submitted entries. */
 294                 foreach (sv, *form1->submit) {
 295                         struct submitted_value *sv2;
 296                         unsigned char *value = NULL;
 297
 298                         count++;
 299                         foreach (sv2, *form->submit) {
 300                                 if (sv->type != sv2->type) continue;
 301                                 if (!strcmp(sv->name, sv2->name)) {
 302                                         exact++;
 303                                         value = sv2->value;
 304                                         break;
 305                                 }
 306                         }
 307                         /* If we found a value for that name, check if value
 308                          * has changed or not. */
 309                         if (value && strcmp(sv->value, value)) return 0;
 310                 }
 311
 312                 /* Check if submitted values have changed or not. */
 313                 if (count && exact && count == exact) return 1;
 314         }
 315
 316         return 0;
 317 }
 318
 319 static int
 320 forget_forms_with_url(unsigned char *url)
 321 {
 322         struct formhist_data *form, *next;
 323         int count = 0;
 324
 325         foreachsafe (form, next, saved_forms) {
 326                 if (strcmp(form->url, url)) continue;
 327
 328                 delete_formhist_item(form);
 329                 count++;
 330         }
 331
 332         return count;
 333 }
 334
 335 /* Appends form data @form_ (url and submitted_value(s)) to the password file. */
 336 static void
 337 remember_form(void *form_)
 338 {
 339         struct formhist_data *form = form_;
 340
 341         forget_forms_with_url(form->url);
 342         add_to_list(saved_forms, form);
 343
 344         save_formhist_to_file();
 345 }
 346
 347 static void
 348 dont_remember_form(void *form_)
 349 {
 350         struct formhist_data *form = form_;
 351
 352         done_formhist_item(form);
 353 }
 354
 355 static void
 356 never_for_this_site(void *form_)
 357 {
 358         struct formhist_data *form = form_;
 359
 360         form->dontsave = 1;
 361         remember_form(form);
 362 }
 363
 364 unsigned char *
 365 get_form_history_value(unsigned char *url, unsigned char *name)
 366 {
 367         struct formhist_data *form;
 368
 369         if (!url || !*url || !name || !*name) return NULL;
 370
 371         if (!load_formhist_from_file()) return NULL;
 372
 373         foreach (form, saved_forms) {
 374                 if (form->dontsave) continue;
 375
 376                 if (!strcmp(form->url, url)) {
 377                         struct submitted_value *sv;
 378
 379                         foreach (sv, *form->submit)
 380                                 if (!strcmp(sv->name, name))
 381                                         return sv->value;
 382                 }
 383         }
 384
 385         return NULL;
 386 }
 387
 388 void
 389 memorize_form(struct session *ses, LIST_OF(struct submitted_value) *submit,
 390               struct form *forminfo)
 391 {
 392         /* [gettext_accelerator_context(memorize_form)] */
 393         struct formhist_data *form;
 394         struct submitted_value *sv;
 395         int save = 0;
 396
 397         /* XXX: For now, we only save these types of form fields. */
 398         foreach (sv, *submit) {
 399                 if (sv->type == FC_PASSWORD && sv->value && *sv->value) {
 400                         save = 1;
 401                         break;
 402                 }
 403         }
 404
 405         if (!save) return;
 406
 407         /* Create a temporary form. */
 408         form = new_formhist_item(forminfo->action);
 409         if (!form) return;
 410
 411         foreach (sv, *submit) {
 412                 if ((sv->type == FC_TEXT) || (sv->type == FC_PASSWORD)) {
 413                         struct submitted_value *sv2;
 414
 415                         sv2 = init_submitted_value(sv->name, sv->value,
 416                                                    sv->type, NULL, 0);
 417                         if (!sv2) goto fail;
 418
 419                         add_to_list(*form->submit, sv2);
 420                 }
 421         }
 422
 423         if (form_exists(form)) goto fail;
 424
 425         msg_box(ses->tab->term, NULL, 0,
 426                 N_("Form history"), ALIGN_CENTER,
 427                 N_("Should this login be remembered?\n\n"
 428                 "Please note that the password will be stored "
 429                 "obscured (but unencrypted) in a file on your disk.\n\n"
 430                 "If you are using a valuable password, answer NO."),
 431                 form, 3,
 432                 MSG_BOX_BUTTON(N_("~Yes"), remember_form, B_ENTER),
 433                 MSG_BOX_BUTTON(N_("~No"), dont_remember_form, B_ESC),
 434                 MSG_BOX_BUTTON(N_("Ne~ver for this site"), never_for_this_site, 0));
 435
 436         return;
 437
 438 fail:
 439         done_formhist_item(form);
 440 }
 441
 442 static void
 443 done_form_history(struct module *module)
 444 {
 445         struct formhist_data *form, *next;
 446
 447         foreachsafe (form, next, saved_forms) {
 448                 delete_formhist_item(form);
 449         }
 450 }
 451
 452 struct module forms_history_module = struct_module(
 453         /* name: */             N_("Form History"),
 454         /* options: */          forms_history_options,
 455         /* events: */           NULL,
 456         /* submodules: */       NULL,
 457         /* data: */             NULL,
 458         /* init: */             NULL,
 459         /* done: */             done_form_history
 460 );