apps/plugins/keybox.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2008 Nils Wallménius
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include "plugin.h"
  22 #include "lib/playback_control.h"
  23 #include "lib/md5.h"
  24
  25
  26 #define KEYBOX_FILE PLUGIN_APPS_DIR "/keybox.dat"
  27 #define BLOCK_SIZE 8
  28 #define MAX_ENTRIES 12*BLOCK_SIZE /* keep this a multiple of BLOCK_SIZE */
  29 #define FIELD_LEN 32 /* should be enough for anyone ;) */
  30
  31 /* The header begins with the unencrypted salt (4 bytes) padded with 4 bytes of
  32    zeroes. After that comes the encrypted hash of the master password (16 bytes) */
  33
  34 #define HEADER_LEN 24
  35
  36 enum
  37 {
  38     FILE_OPEN_ERROR = -1
  39 };
  40
  41 struct pw_entry
  42 {
  43     bool used;
  44     char title[FIELD_LEN];
  45     char name[FIELD_LEN];
  46     char password[FIELD_LEN];
  47     struct pw_entry *next;
  48 };
  49
  50 struct pw_list
  51 {
  52     struct pw_entry first; /* always points to the first element in the list */
  53     struct pw_entry entries[MAX_ENTRIES];
  54     int num_entries;
  55 } pw_list;
  56
  57 /* use this to access hashes in different ways, not byte order
  58    independent but does it matter? */
  59 union hash
  60 {
  61     uint8_t bytes[16];
  62     uint32_t words[4];
  63 };
  64
  65 static char buffer[sizeof(struct pw_entry)*MAX_ENTRIES];
  66 static int bytes_read = 0; /* bytes read into the buffer */
  67 static struct gui_synclist kb_list;
  68 static union hash key;
  69 static char master_pw[FIELD_LEN];
  70 static uint32_t salt;
  71 static union hash pwhash;
  72 static bool data_changed = false;
  73
  74 static void encrypt_buffer(char *buf, size_t size, uint32_t *key);
  75 static void decrypt_buffer(char *buf, size_t size, uint32_t *key);
  76
  77 /* the following two functions are the reference TEA implementation by
  78    David Wheeler and Roger Needham taken from
  79    http://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm */
  80
  81 static void encrypt(uint32_t* v, uint32_t* k)
  82 {
  83     uint32_t v0=v[0], v1=v[1], sum=0, i;           /* set up */
  84     static const uint32_t delta=0x9e3779b9;        /* a key schedule constant */
  85     uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3];   /* cache key */
  86     for (i=0; i < 32; i++) {                            /* basic cycle start */
  87         sum += delta;
  88         v0 += ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
  89         v1 += ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);  /* end cycle */
  90     }
  91     v[0]=v0; v[1]=v1;
  92 }
  93
  94 static void decrypt(uint32_t* v, uint32_t* k)
  95 {
  96     uint32_t v0=v[0], v1=v[1], sum=0xC6EF3720, i;  /* set up */
  97     static const uint32_t delta=0x9e3779b9;        /* a key schedule constant */
  98     uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3];   /* cache key */
  99     for (i=0; i<32; i++) {                              /* basic cycle start */
 100         v1 -= ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
 101         v0 -= ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
 102         sum -= delta;                                   /* end cycle */
 103     }
 104     v[0]=v0; v[1]=v1;
 105 }
 106
 107 static int context_item_cb(int action, const struct menu_item_ex *this_item)
 108 {
 109     int i = (intptr_t)this_item;
 110     if (action == ACTION_REQUEST_MENUITEM
 111         && pw_list.num_entries == 0
 112         && (i != 0 && i != 5))
 113     {
 114         return ACTION_EXIT_MENUITEM;
 115     }
 116     return action;
 117 }
 118
 119 MENUITEM_STRINGLIST(context_m, "Context menu", context_item_cb,
 120                     "Add entry",
 121                     "Edit title", "Edit user name", "Edit password",
 122                     "Delete entry",
 123                     "Playback Control");
 124
 125 static const char* kb_list_cb(int selected_item, void *data,
 126                               char *buffer, size_t buffer_len)
 127 {
 128     (void)data;
 129     int i;
 130     struct pw_entry *entry = pw_list.first.next;
 131     for (i = 0; i < selected_item; i++)
 132     {
 133         if (entry)
 134             entry = entry->next;
 135     }
 136     if (!entry)
 137         return NULL;
 138
 139     rb->snprintf(buffer, buffer_len, "%s", entry->title);
 140
 141     return buffer;
 142 }
 143
 144 static void init_ll(void)
 145 {
 146     pw_list.first.next = &pw_list.entries[0];
 147     pw_list.entries[0].next = NULL;
 148     pw_list.num_entries = 0;
 149 }
 150
 151 static void delete_entry(int selected_item)
 152 {
 153     int i;
 154     struct pw_entry *entry = &pw_list.first;
 155     struct pw_entry *entry2;
 156
 157     /* find the entry before the one to delete */
 158     for (i = 0; i < selected_item; i++)
 159     {
 160         if (entry->next)
 161             entry = entry->next;
 162     }
 163     entry2 = entry->next;
 164     if (!entry2)
 165         return;
 166
 167     entry->next = entry2->next;
 168
 169     entry2->used = false;
 170     entry2->name[0] = '\0';
 171     entry2->password[0] = '\0';
 172     entry2->next = NULL;
 173
 174     rb->gui_synclist_set_nb_items(&kb_list, --pw_list.num_entries);
 175     if(!pw_list.num_entries)
 176         init_ll();
 177     data_changed = true;
 178 }
 179
 180 static void add_entry(int selected_item)
 181 {
 182     int i, j;
 183     struct pw_entry *entry = pw_list.first.next;
 184     for (i = 0; i < MAX_ENTRIES && pw_list.entries[i].used; i++)
 185         ;
 186
 187     if (MAX_ENTRIES == i)
 188     {
 189         rb->splash(HZ, "Password list full");
 190         return;
 191     }
 192
 193     rb->splash(HZ, "Enter title");
 194     pw_list.entries[i].title[0] = '\0';
 195     if (rb->kbd_input(pw_list.entries[i].title, FIELD_LEN) < 0)
 196         return;
 197
 198     rb->splash(HZ, "Enter name");
 199     pw_list.entries[i].name[0] = '\0';
 200     if (rb->kbd_input(pw_list.entries[i].name, FIELD_LEN) < 0)
 201     {
 202         pw_list.entries[i].title[0] = '\0';
 203         return;
 204     }
 205
 206     rb->splash(HZ, "Enter password");
 207     pw_list.entries[i].password[0] = '\0';
 208     if (rb->kbd_input(pw_list.entries[i].password, FIELD_LEN) < 0)
 209     {
 210         pw_list.entries[i].title[0] = '\0';
 211         pw_list.entries[i].name[0] = '\0';
 212         return;
 213     }
 214
 215     for (j = 0; j < selected_item; j++)
 216     {
 217         if (entry->next)
 218             entry = entry->next;
 219     }
 220
 221     rb->gui_synclist_set_nb_items(&kb_list, ++pw_list.num_entries);
 222
 223     pw_list.entries[i].used = true;
 224     pw_list.entries[i].next = entry->next;
 225
 226     entry->next = &pw_list.entries[i];
 227
 228     if (entry->next == entry)
 229         entry->next = NULL;
 230
 231     data_changed = true;
 232 }
 233
 234 static void edit_title(int selected_item)
 235 {
 236     int i;
 237     struct pw_entry *entry = pw_list.first.next;
 238     for (i = 0; i < selected_item; i++)
 239     {
 240         if (entry->next)
 241             entry = entry->next;
 242     }
 243     if (rb->kbd_input(entry->title, FIELD_LEN) == 0)
 244         data_changed = true;
 245 }
 246
 247 static void edit_name(int selected_item)
 248 {
 249     int i;
 250     struct pw_entry *entry = pw_list.first.next;
 251     for (i = 0; i < selected_item; i++)
 252     {
 253         if (entry->next)
 254             entry = entry->next;
 255     }
 256     if (rb->kbd_input(entry->name, FIELD_LEN) == 0)
 257         data_changed = true;
 258 }
 259
 260 static void edit_pw(int selected_item)
 261 {
 262     int i;
 263     struct pw_entry *entry = pw_list.first.next;
 264     for (i = 0; i < selected_item; i++)
 265     {
 266         if (entry->next)
 267             entry = entry->next;
 268     }
 269     if (rb->kbd_input(entry->password, FIELD_LEN) == 0)
 270         data_changed = true;
 271 }
 272
 273 static void context_menu(int selected_item)
 274 {
 275     int selection = 0, result;
 276     bool exit = false;
 277
 278     do {
 279         result = rb->do_menu(&context_m, &selection, NULL, false);
 280         switch (result) {
 281         case 0:
 282             add_entry(selected_item);
 283             return;
 284         case 1:
 285             edit_title(selected_item);
 286             return;
 287         case 2:
 288             edit_name(selected_item);
 289             return;
 290         case 3:
 291             edit_pw(selected_item);
 292             return;
 293         case 4:
 294             delete_entry(selected_item);
 295             return;
 296         case 5:
 297             playback_control(NULL);
 298             return;
 299         default:
 300             exit = true;
 301             break;
 302         }
 303         rb->yield();
 304     } while (!exit);
 305 }
 306
 307 static void splash_pw(int selected_item)
 308 {
 309     int i;
 310     struct pw_entry *entry = pw_list.first.next;
 311
 312     for (i = 0; i < selected_item; i++)
 313     {
 314         if (entry->next)
 315             entry = entry->next;
 316     }
 317     if (entry->name != '\0')
 318         rb->splashf(0, "%s  %s", entry->name, entry->password);
 319     else
 320         rb->splashf(0, "%s", entry->password);
 321     rb->get_action(CONTEXT_STD, TIMEOUT_BLOCK);
 322 }
 323
 324 static void hash_pw(union hash *out)
 325 {
 326     int i;
 327     struct md5_s pw_md5;
 328
 329     InitMD5(&pw_md5);
 330     AddMD5(&pw_md5, master_pw, rb->strlen(master_pw));
 331     EndMD5(&pw_md5);
 332
 333     for (i = 0; i < 4; i++)
 334         out->words[i] = htole32(pw_md5.p_digest[i]);
 335 }
 336
 337 static void make_key(void)
 338 {
 339     int i;
 340     char buf[sizeof(master_pw) + sizeof(salt) + 1] = {0};
 341     struct md5_s key_md5;
 342     size_t len = rb->strlen(master_pw);
 343
 344     rb->strlcpy(buf, master_pw, sizeof(buf));
 345
 346     rb->memcpy(&buf[len], &salt, sizeof(salt));
 347
 348     InitMD5(&key_md5);
 349     AddMD5(&key_md5, buf, rb->strlen(buf));
 350     EndMD5(&key_md5);
 351
 352     for (i = 0; i < 4; i++)
 353         key.words[i] = key_md5.p_digest[i];
 354 }
 355
 356 static void decrypt_buffer(char *buf, size_t size, uint32_t *key)
 357 {
 358     unsigned int i;
 359     uint32_t block[2];
 360
 361     for (i = 0; i < size/BLOCK_SIZE; i++)
 362     {
 363         rb->memcpy(&block[0], &buf[i*BLOCK_SIZE], sizeof(block));
 364
 365         block[0] = letoh32(block[0]);
 366         block[1] = letoh32(block[1]);
 367
 368         decrypt(&block[0], key);
 369
 370         /* byte swap one block */
 371         block[0] = letoh32(block[0]);
 372         block[1] = letoh32(block[1]);
 373
 374         rb->memcpy(&buf[i*BLOCK_SIZE], &block[0], sizeof(block));
 375     }
 376 }
 377
 378 static void encrypt_buffer(char *buf, size_t size, uint32_t *key)
 379 {
 380     unsigned int i;
 381     uint32_t block[2];
 382
 383     for (i = 0; i < size/BLOCK_SIZE; i++)
 384     {
 385         rb->memcpy(&block[0], &buf[i*BLOCK_SIZE], sizeof(block));
 386
 387         /* byte swap one block */
 388         block[0] = htole32(block[0]);
 389         block[1] = htole32(block[1]);
 390
 391         encrypt(&block[0], key);
 392
 393         block[0] = htole32(block[0]);
 394         block[1] = htole32(block[1]);
 395
 396         rb->memcpy(&buf[i*BLOCK_SIZE], &block[0], sizeof(block));
 397     }
 398 }
 399
 400 static int parse_buffer(void)
 401 {
 402     int i;
 403     int len;
 404     struct pw_entry *entry = pw_list.first.next;
 405     char *start, *end;
 406     start = &buffer[HEADER_LEN];
 407
 408     rb->memcpy(&salt, &buffer[0], sizeof(salt));
 409     make_key();
 410
 411     decrypt_buffer(&buffer[8], bytes_read - 8, &key.words[0]);
 412
 413     if (rb->memcmp(&buffer[8], &pwhash, sizeof(union hash)))
 414     {
 415         rb->splash(HZ*2, "Wrong password");
 416         return -1;
 417     }
 418
 419     for (i = 0; i < MAX_ENTRIES; i++)
 420     {
 421         end = rb->strchr(start, '\0'); /* find eol */
 422         len = end - &buffer[HEADER_LEN];
 423         if ((len > bytes_read + HEADER_LEN) || start == end)
 424         {
 425             break;
 426         }
 427
 428         rb->strlcpy(entry->title, start, FIELD_LEN);
 429         start = end + 1;
 430
 431         end = rb->strchr(start, '\0'); /* find eol */
 432         len = end - &buffer[HEADER_LEN];
 433         if (len > bytes_read + HEADER_LEN)
 434         {
 435             break;
 436         }
 437
 438         rb->strlcpy(entry->name, start, FIELD_LEN);
 439         start = end + 1;
 440
 441         end = rb->strchr(start, '\0'); /* find eol */
 442         len = end - &buffer[HEADER_LEN];
 443         if (len > bytes_read + HEADER_LEN)
 444         {
 445             break;
 446         }
 447         rb->strlcpy(entry->password, start, FIELD_LEN);
 448         start = end + 1;
 449         entry->used = true;
 450         if (i + 1 < MAX_ENTRIES - 1)
 451         {
 452             entry->next = &pw_list.entries[i+1];
 453             entry = entry->next;
 454         }
 455         else
 456         {
 457             break;
 458         }
 459     }
 460     entry->next = NULL;
 461     pw_list.num_entries = i;
 462     rb->gui_synclist_set_nb_items(&kb_list, pw_list.num_entries);
 463     return 0;
 464 }
 465
 466 static void write_output(int fd)
 467 {
 468     size_t bytes_written;
 469     int i;
 470     size_t len, size;
 471     char *p = &buffer[HEADER_LEN]; /* reserve space for salt + hash */
 472
 473     rb->memcpy(&buffer[8], &pwhash, sizeof(union hash));
 474     struct pw_entry *entry = pw_list.first.next;
 475
 476     for (i = 0; i < pw_list.num_entries; i++)
 477     {
 478         len = rb->strlen(entry->title);
 479         rb->strlcpy(p, entry->title, len+1);
 480         p += len+1;
 481         len = rb->strlen(entry->name);
 482         rb->strlcpy(p, entry->name, len+1);
 483         p += len+1;
 484         len = rb->strlen(entry->password);
 485         rb->strlcpy(p, entry->password, len+1);
 486         p += len+1;
 487         if (entry->next)
 488             entry = entry->next;
 489     }
 490     *p++ = '\0'; /* mark the end of the list */
 491
 492     /* round up to a number divisible by BLOCK_SIZE */
 493     size = ((p - buffer + BLOCK_SIZE - 1) / BLOCK_SIZE) * BLOCK_SIZE;
 494
 495     salt = rb->rand();
 496     make_key();
 497
 498     encrypt_buffer(&buffer[8], size, &key.words[0]);
 499     rb->memcpy(&buffer[0], &salt, sizeof(salt));
 500
 501     bytes_written = rb->write(fd, &buffer, size);
 502 }
 503
 504 static int enter_pw(char *pw_buf, size_t buflen, bool new_pw)
 505 {
 506     char buf[2][sizeof(master_pw)];
 507     rb->memset(buf, 0, sizeof(buf));
 508     rb->memset(master_pw, 0, sizeof(master_pw));
 509
 510     if (new_pw)
 511     {
 512         rb->splash(HZ, "Enter new master password");
 513         if (rb->kbd_input(buf[0], sizeof(buf[0])) < 0)
 514             return -1;
 515
 516         rb->splash(HZ, "Confirm master password");
 517         if (rb->kbd_input(buf[1], sizeof(buf[1])) < 0)
 518             return -1;
 519
 520         if (rb->strcmp(buf[0], buf[1]))
 521         {
 522             rb->splash(HZ, "Password mismatch");
 523             return -1;
 524         }
 525         else
 526         {
 527             rb->strlcpy(pw_buf, buf[0], buflen);
 528             hash_pw(&pwhash);
 529             return 0;
 530         }
 531     }
 532
 533     rb->splash(HZ, "Enter master password");
 534     if (rb->kbd_input(pw_buf, buflen) < 0)
 535         return -1;
 536     hash_pw(&pwhash);
 537     return 0;
 538 }
 539
 540 static int keybox(void)
 541 {
 542     int button, fd;
 543     bool new_file = !rb->file_exists(KEYBOX_FILE);
 544     bool done = false;
 545
 546     if (enter_pw(master_pw, sizeof (master_pw), new_file))
 547         return 0;
 548
 549     /* Read the existing file */
 550     if (!new_file)
 551     {
 552         fd = rb->open(KEYBOX_FILE, O_RDONLY);
 553         if (fd < 0)
 554             return FILE_OPEN_ERROR;
 555         bytes_read = rb->read(fd, &buffer, sizeof(buffer));
 556
 557         rb->close(fd);
 558
 559         if (parse_buffer())
 560             return 0;
 561     }
 562
 563     while (!done)
 564     {
 565         rb->gui_synclist_draw(&kb_list);
 566         button = rb->get_action(CONTEXT_LIST, TIMEOUT_BLOCK);
 567         if (rb->gui_synclist_do_button(&kb_list, &button, LIST_WRAP_ON))
 568             continue;
 569
 570         switch (button)
 571         {
 572             case ACTION_STD_OK:
 573                 splash_pw(rb->gui_synclist_get_sel_pos(&kb_list));
 574                 break;
 575             case ACTION_STD_CONTEXT:
 576                 context_menu(rb->gui_synclist_get_sel_pos(&kb_list));
 577                 break;
 578             case ACTION_STD_CANCEL:
 579                 done = true;
 580                 break;
 581         }
 582         rb->yield();
 583     }
 584
 585     if (data_changed)
 586     {
 587         fd = rb->open(KEYBOX_FILE, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 588         if (fd < 0)
 589             return FILE_OPEN_ERROR;
 590         write_output(fd);
 591         rb->close(fd);
 592     }
 593
 594     return 0;
 595 }
 596
 597 static void reset(void)
 598 {
 599     static const char *message_lines[]=
 600         {"Do you really want", "to reset keybox?"};
 601     static const char *yes_lines[]=
 602         {"Keybox reset."};
 603     static const struct text_message message={message_lines, 2};
 604     static const struct text_message yes_message={yes_lines, 1};
 605
 606     if(rb->gui_syncyesno_run(&message, &yes_message, NULL) == YESNO_YES)
 607     {
 608         rb->remove(KEYBOX_FILE);
 609         rb->memset(&buffer, 0, sizeof(buffer));
 610         rb->memset(&pw_list, 0, sizeof(pw_list));
 611         rb->gui_synclist_set_nb_items(&kb_list, 0);
 612         init_ll();
 613     }
 614 }
 615
 616 static int main_menu(void)
 617 {
 618     int selection = 0, result, ret;
 619     bool exit = false;
 620
 621     MENUITEM_STRINGLIST(menu, "Keybox", NULL,
 622                         "Enter Keybox", "Reset Keybox",
 623                         "Playback Control", "Exit");
 624
 625     do {
 626         result = rb->do_menu(&menu, &selection, NULL, false);
 627         switch (result) {
 628         case 0:
 629             ret = keybox();
 630             if (ret)
 631                 return ret;
 632             break;
 633         case 1:
 634             reset();
 635             break;
 636         case 2:
 637             playback_control(NULL);
 638             break;
 639         case 3:
 640             exit = true;
 641             break;
 642         }
 643         rb->yield();
 644     } while (!exit);
 645
 646     return 0;
 647 }
 648
 649 enum plugin_status plugin_start(const void *parameter)
 650 {
 651     (void)parameter;
 652     int ret;
 653
 654     rb->gui_synclist_init(&kb_list, &kb_list_cb, NULL, false, 1, NULL);
 655
 656     rb->gui_synclist_set_title(&kb_list, "Keybox", NOICON);
 657     rb->gui_synclist_set_icon_callback(&kb_list, NULL);
 658     rb->gui_synclist_set_nb_items(&kb_list, 0);
 659     rb->gui_synclist_limit_scroll(&kb_list, false);
 660     rb->gui_synclist_select_item(&kb_list, 0);
 661
 662     init_ll();
 663     ret = main_menu();
 664
 665     switch (ret)
 666     {
 667         case FILE_OPEN_ERROR:
 668             rb->splash(HZ*2, "Error opening file");
 669             return PLUGIN_ERROR;
 670     }
 671
 672     return PLUGIN_OK;
 673 }
 674