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 PLUGIN_HEADER
  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 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     data_changed = true;
 176 }
 177
 178 static void add_entry(int selected_item)
 179 {
 180     int i, j;
 181     struct pw_entry *entry = pw_list.first.next;
 182     for (i = 0; i < MAX_ENTRIES && pw_list.entries[i].used; i++)
 183         ;
 184
 185     if (pw_list.entries[i].used)
 186     {
 187         rb->splash(HZ, "Password list full");
 188         return;
 189     }
 190
 191     rb->splash(HZ, "Enter title");
 192     pw_list.entries[i].title[0] = '\0';
 193     if (rb->kbd_input(pw_list.entries[i].title, FIELD_LEN))
 194         return;
 195
 196     rb->splash(HZ, "Enter name");
 197     pw_list.entries[i].name[0] = '\0';
 198     if (rb->kbd_input(pw_list.entries[i].name, FIELD_LEN))
 199     {
 200         pw_list.entries[i].title[0] = '\0';
 201         return;
 202     }
 203
 204     rb->splash(HZ, "Enter password");
 205     pw_list.entries[i].password[0] = '\0';
 206     if (rb->kbd_input(pw_list.entries[i].password, FIELD_LEN))
 207     {
 208         pw_list.entries[i].title[0] = '\0';
 209         pw_list.entries[i].name[0] = '\0';
 210         return;
 211     }
 212
 213     for (j = 0; j < selected_item; j++)
 214     {
 215         if (entry->next)
 216             entry = entry->next;
 217     }
 218
 219     rb->gui_synclist_set_nb_items(&kb_list, ++pw_list.num_entries);
 220
 221     pw_list.entries[i].used = true;
 222     pw_list.entries[i].next = entry->next;
 223
 224     entry->next = &pw_list.entries[i];
 225
 226     if (entry->next == entry)
 227         entry->next = NULL;
 228
 229     data_changed = true;
 230 }
 231
 232 static void edit_title(int selected_item)
 233 {
 234     int i;
 235     struct pw_entry *entry = pw_list.first.next;
 236     for (i = 0; i < selected_item; i++)
 237     {
 238         if (entry->next)
 239             entry = entry->next;
 240     }
 241     if (rb->kbd_input(entry->title, FIELD_LEN) == 0)
 242         data_changed = true;
 243 }
 244
 245 static void edit_name(int selected_item)
 246 {
 247     int i;
 248     struct pw_entry *entry = pw_list.first.next;
 249     for (i = 0; i < selected_item; i++)
 250     {
 251         if (entry->next)
 252             entry = entry->next;
 253     }
 254     if (rb->kbd_input(entry->name, FIELD_LEN) == 0)
 255         data_changed = true;
 256 }
 257
 258 static void edit_pw(int selected_item)
 259 {
 260     int i;
 261     struct pw_entry *entry = pw_list.first.next;
 262     for (i = 0; i < selected_item; i++)
 263     {
 264         if (entry->next)
 265             entry = entry->next;
 266     }
 267     if (rb->kbd_input(entry->password, FIELD_LEN) == 0)
 268         data_changed = true;
 269 }
 270
 271 static void context_menu(int selected_item)
 272 {
 273     int selection, result;
 274     bool exit = false;
 275
 276     do {
 277         result = rb->do_menu(&context_m, &selection, NULL, false);
 278         switch (result) {
 279         case 0:
 280             add_entry(selected_item);
 281             return;
 282         case 1:
 283             edit_title(selected_item);
 284             return;
 285         case 2:
 286             edit_name(selected_item);
 287             return;
 288         case 3:
 289             edit_pw(selected_item);
 290             return;
 291         case 4:
 292             delete_entry(selected_item);
 293             return;
 294         case 5:
 295             playback_control(NULL);
 296             return;
 297         default:
 298             exit = true;
 299             break;
 300         }
 301         rb->yield();
 302     } while (!exit);
 303 }
 304
 305 static void splash_pw(int selected_item)
 306 {
 307     int i;
 308     struct pw_entry *entry = pw_list.first.next;
 309
 310     for (i = 0; i < selected_item; i++)
 311     {
 312         if (entry->next)
 313             entry = entry->next;
 314     }
 315     if (entry->name != '\0')
 316         rb->splashf(0, "%s  %s", entry->name, entry->password);
 317     else
 318         rb->splashf(0, "%s", entry->password);
 319     rb->get_action(CONTEXT_STD, TIMEOUT_BLOCK);
 320 }
 321
 322 static void hash_pw(union hash *out)
 323 {
 324     int i;
 325     struct md5_s pw_md5;
 326
 327     InitMD5(&pw_md5);
 328     AddMD5(&pw_md5, master_pw, rb->strlen(master_pw));
 329     EndMD5(&pw_md5);
 330
 331     for (i = 0; i < 4; i++)
 332         out->words[i] = htole32(pw_md5.p_digest[i]);
 333 }
 334
 335 static void make_key(void)
 336 {
 337     int i;
 338     char buf[sizeof(master_pw) + sizeof(salt) + 1] = {0};
 339     struct md5_s key_md5;
 340     size_t len = rb->strlen(master_pw);
 341
 342     rb->strlcpy(buf, master_pw, sizeof(buf));
 343
 344     rb->memcpy(&buf[len], &salt, sizeof(salt));
 345
 346     InitMD5(&key_md5);
 347     AddMD5(&key_md5, buf, rb->strlen(buf));
 348     EndMD5(&key_md5);
 349
 350     for (i = 0; i < 4; i++)
 351         key.words[i] = key_md5.p_digest[i];
 352 }
 353
 354 static void decrypt_buffer(char *buf, size_t size, uint32_t *key)
 355 {
 356     unsigned int i;
 357     uint32_t block[2];
 358
 359     for (i = 0; i < size/BLOCK_SIZE; i++)
 360     {
 361         rb->memcpy(&block[0], &buf[i*BLOCK_SIZE], sizeof(block));
 362
 363         block[0] = letoh32(block[0]);
 364         block[1] = letoh32(block[1]);
 365
 366         decrypt(&block[0], key);
 367
 368         /* byte swap one block */
 369         block[0] = letoh32(block[0]);
 370         block[1] = letoh32(block[1]);
 371
 372         rb->memcpy(&buf[i*BLOCK_SIZE], &block[0], sizeof(block));
 373     }
 374 }
 375
 376 static void encrypt_buffer(char *buf, size_t size, uint32_t *key)
 377 {
 378     unsigned int i;
 379     uint32_t block[2];
 380
 381     for (i = 0; i < size/BLOCK_SIZE; i++)
 382     {
 383         rb->memcpy(&block[0], &buf[i*BLOCK_SIZE], sizeof(block));
 384
 385         /* byte swap one block */
 386         block[0] = htole32(block[0]);
 387         block[1] = htole32(block[1]);
 388
 389         encrypt(&block[0], key);
 390
 391         block[0] = htole32(block[0]);
 392         block[1] = htole32(block[1]);
 393
 394         rb->memcpy(&buf[i*BLOCK_SIZE], &block[0], sizeof(block));
 395     }
 396 }
 397
 398 static int parse_buffer(void)
 399 {
 400     int i;
 401     int len;
 402     struct pw_entry *entry = pw_list.first.next;
 403     char *start, *end;
 404     start = &buffer[HEADER_LEN];
 405
 406     rb->memcpy(&salt, &buffer[0], sizeof(salt));
 407     make_key();
 408
 409     decrypt_buffer(&buffer[8], bytes_read - 8, &key.words[0]);
 410
 411     if (rb->memcmp(&buffer[8], &pwhash, sizeof(union hash)))
 412     {
 413         rb->splash(HZ*2, "Wrong password");
 414         return -1;
 415     }
 416
 417     for (i = 0; i < MAX_ENTRIES; i++)
 418     {
 419         end = rb->strchr(start, '\0'); /* find eol */
 420         len = end - &buffer[HEADER_LEN];
 421         if ((len > bytes_read + HEADER_LEN) || start == end)
 422         {
 423             break;
 424         }
 425
 426         rb->strlcpy(entry->title, start, FIELD_LEN);
 427         start = end + 1;
 428
 429         end = rb->strchr(start, '\0'); /* find eol */
 430         len = end - &buffer[HEADER_LEN];
 431         if (len > bytes_read + HEADER_LEN)
 432         {
 433             break;
 434         }
 435
 436         rb->strlcpy(entry->name, start, FIELD_LEN);
 437         start = end + 1;
 438
 439         end = rb->strchr(start, '\0'); /* find eol */
 440         len = end - &buffer[HEADER_LEN];
 441         if (len > bytes_read + HEADER_LEN)
 442         {
 443             break;
 444         }
 445         rb->strlcpy(entry->password, start, FIELD_LEN);
 446         start = end + 1;
 447         entry->used = true;
 448         if (i + 1 < MAX_ENTRIES - 1)
 449         {
 450             entry->next = &pw_list.entries[i+1];
 451             entry = entry->next;
 452         }
 453         else
 454         {
 455             break;
 456         }
 457     }
 458     entry->next = NULL;
 459     pw_list.num_entries = i;
 460     rb->gui_synclist_set_nb_items(&kb_list, pw_list.num_entries);
 461     return 0;
 462 }
 463
 464 static void write_output(int fd)
 465 {
 466     size_t bytes_written;
 467     int i;
 468     size_t len, size;
 469     char *p = &buffer[HEADER_LEN]; /* reserve space for salt + hash */
 470
 471     rb->memcpy(&buffer[8], &pwhash, sizeof(union hash));
 472     struct pw_entry *entry = pw_list.first.next;
 473
 474     for (i = 0; i < pw_list.num_entries; i++)
 475     {
 476         len = rb->strlen(entry->title);
 477         rb->strlcpy(p, entry->title, len+1);
 478         p += len+1;
 479         len = rb->strlen(entry->name);
 480         rb->strlcpy(p, entry->name, len+1);
 481         p += len+1;
 482         len = rb->strlen(entry->password);
 483         rb->strlcpy(p, entry->password, len+1);
 484         p += len+1;
 485         if (entry->next)
 486             entry = entry->next;
 487     }
 488     *p++ = '\0'; /* mark the end of the list */
 489
 490     /* round up to a number divisible by BLOCK_SIZE */
 491     size = ((p - buffer + BLOCK_SIZE - 1) / BLOCK_SIZE) * BLOCK_SIZE;
 492
 493     salt = rb->rand();
 494     make_key();
 495
 496     encrypt_buffer(&buffer[8], size, &key.words[0]);
 497     rb->memcpy(&buffer[0], &salt, sizeof(salt));
 498
 499     bytes_written = rb->write(fd, &buffer, size);
 500 }
 501
 502 static int enter_pw(char *pw_buf, size_t buflen, bool new_pw)
 503 {
 504     char buf[2][sizeof(master_pw)];
 505     rb->memset(buf, 0, sizeof(buf));
 506     rb->memset(master_pw, 0, sizeof(master_pw));
 507
 508     if (new_pw)
 509     {
 510         rb->splash(HZ, "Enter new master password");
 511         if (rb->kbd_input(buf[0], sizeof(buf[0])))
 512             return -1;
 513
 514         rb->splash(HZ, "Confirm master password");
 515         if (rb->kbd_input(buf[1], sizeof(buf[1])))
 516             return -1;
 517
 518         if (rb->strcmp(buf[0], buf[1]))
 519         {
 520             rb->splash(HZ, "Password mismatch");
 521             return -1;
 522         }
 523         else
 524         {
 525             rb->strlcpy(pw_buf, buf[0], buflen);
 526             hash_pw(&pwhash);
 527             return 0;
 528         }
 529     }
 530
 531     rb->splash(HZ, "Enter master password");
 532     if (rb->kbd_input(pw_buf, buflen))
 533         return -1;
 534     hash_pw(&pwhash);
 535     return 0;
 536 }
 537
 538 static int keybox(void)
 539 {
 540     int button, fd;
 541     bool new_file = !rb->file_exists(KEYBOX_FILE);
 542     bool done = false;
 543
 544     if (enter_pw(master_pw, sizeof (master_pw), new_file))
 545         return 0;
 546
 547     /* Read the existing file */
 548     if (!new_file)
 549     {
 550         fd = rb->open(KEYBOX_FILE, O_RDONLY);
 551         if (fd < 0)
 552             return FILE_OPEN_ERROR;
 553         bytes_read = rb->read(fd, &buffer, sizeof(buffer));
 554
 555         if (parse_buffer())
 556             return 0;
 557
 558         rb->close(fd);
 559     }
 560
 561     while (!done)
 562     {
 563         rb->gui_synclist_draw(&kb_list);
 564         button = rb->get_action(CONTEXT_LIST, TIMEOUT_BLOCK);
 565         if (rb->gui_synclist_do_button(&kb_list, &button, LIST_WRAP_ON))
 566             continue;
 567
 568         switch (button)
 569         {
 570             case ACTION_STD_OK:
 571                 splash_pw(rb->gui_synclist_get_sel_pos(&kb_list));
 572                 break;
 573             case ACTION_STD_CONTEXT:
 574                 context_menu(rb->gui_synclist_get_sel_pos(&kb_list));
 575                 break;
 576             case ACTION_STD_CANCEL:
 577                 done = true;
 578                 break;
 579         }
 580         rb->yield();
 581     }
 582
 583     if (data_changed)
 584     {
 585         fd = rb->open(KEYBOX_FILE, O_WRONLY | O_CREAT | O_TRUNC);
 586         if (fd < 0)
 587             return FILE_OPEN_ERROR;
 588         write_output(fd);
 589         rb->close(fd);
 590     }
 591
 592     return 0;
 593 }
 594
 595 static void reset(void)
 596 {
 597     static const char *message_lines[]=
 598         {"Do you really want", "to reset keybox?"};
 599     static const char *yes_lines[]=
 600         {"Keybox reset."};
 601     static const struct text_message message={message_lines, 2};
 602     static const struct text_message yes_message={yes_lines, 1};
 603
 604     if(rb->gui_syncyesno_run(&message, &yes_message, NULL) == YESNO_YES)
 605     {
 606         rb->remove(KEYBOX_FILE);
 607         rb->memset(&buffer, 0, sizeof(buffer));
 608         rb->memset(&pw_list, 0, sizeof(pw_list));
 609         init_ll();
 610     }
 611 }
 612
 613 static int main_menu(void)
 614 {
 615     int selection, result, ret;
 616     bool exit = false;
 617
 618     MENUITEM_STRINGLIST(menu, "Keybox", NULL,
 619                         "Enter Keybox", "Reset Keybox",
 620                         "Playback Control", "Exit");
 621
 622     do {
 623         result = rb->do_menu(&menu, &selection, NULL, false);
 624         switch (result) {
 625         case 0:
 626             ret = keybox();
 627             if (ret)
 628                 return ret;
 629             break;
 630         case 1:
 631             reset();
 632             break;
 633         case 2:
 634             playback_control(NULL);
 635             break;
 636         case 3:
 637             exit = true;
 638             break;
 639         }
 640         rb->yield();
 641     } while (!exit);
 642
 643     return 0;
 644 }
 645
 646 enum plugin_status plugin_start(const void *parameter)
 647 {
 648     (void)parameter;
 649     int ret;
 650
 651     rb->gui_synclist_init(&kb_list, &kb_list_cb, NULL, false, 1, NULL);
 652
 653     rb->gui_synclist_set_title(&kb_list, "Keybox", NOICON);
 654     rb->gui_synclist_set_icon_callback(&kb_list, NULL);
 655     rb->gui_synclist_set_nb_items(&kb_list, 0);
 656     rb->gui_synclist_limit_scroll(&kb_list, false);
 657     rb->gui_synclist_select_item(&kb_list, 0);
 658
 659     init_ll();
 660     ret = main_menu();
 661
 662     switch (ret)
 663     {
 664         case FILE_OPEN_ERROR:
 665             rb->splash(HZ*2, "Error opening file");
 666             return PLUGIN_ERROR;
 667     }
 668
 669     return PLUGIN_OK;
 670 }
 671