libotp.c

   1 /** Practical One-time Pad Library
   2  *
   3  * Created:20080514
   4  * By Jeff Connelly
   5  */
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <sysexits.h>
  10 #include <string.h>
  11
  12 #include "libotp.h"
  13
  14 PAD *pads = NULL;
  15
  16 /** Show a list of all loaded pads. */
  17 void show_pads()
  18 {
  19     PAD *p;
  20
  21     for (p = pads; p; p = p->next) {
  22         printf("Pad: %s: %s\n", p->name, p->local_filename);
  23     }
  24 }
  25
  26 /** Open a companion offset file for given pad. Caller must close.
  27  *
  28  * @param mode Either "rt" or "wt", for reading or writing.
  29  */
  30 FILE *open_offset_file(PAD *p, char *mode)
  31 {
  32     FILE *ofp;
  33     char *offset_filename;
  34     size_t filename_length;
  35
  36     /* Offset is stored in a separate file; pad plus OFFSET_FILE_NAME_EXTENSION. */
  37     filename_length = strlen(p->local_filename) + strlen(OFFSET_FILE_EXTENSION) + 1;
  38     offset_filename = malloc(filename_length);
  39     if (!offset_filename) {
  40         perror("malloc");
  41         exit(EX_UNAVAILABLE);
  42     }
  43     snprintf(offset_filename, filename_length, "%s" OFFSET_FILE_EXTENSION, p->local_filename);
  44
  45     /* Read offset from file. */
  46     ofp = fopen(offset_filename, mode);
  47     if (!ofp) {
  48         fprintf(stderr, "opening offset file %s failed\n", offset_filename);
  49         perror("fopen");
  50         free(offset_filename);
  51         exit(EX_IOERR);
  52     }
  53     free(offset_filename);
  54
  55     return ofp;
  56 }
  57
  58 /** Read the pad offset of a given pad. */
  59 unsigned long read_offset(PAD *p)
  60 {
  61     FILE *ofp;
  62     char buffer[OFFSET_SIZE];
  63     unsigned long offset;
  64
  65     ofp = open_offset_file(p, "rt");
  66
  67     memset(buffer, 0, OFFSET_SIZE);
  68     if (fread(buffer, 1, OFFSET_SIZE - 1, ofp) < 1) {
  69         fprintf(stderr, "could not read offset file for %s\n", p->local_filename);
  70         exit(EX_IOERR);
  71     }
  72
  73     if (fclose(ofp) != 0) {
  74         fprintf(stderr, "error closing offset file for reading for %s\n", p->local_filename);
  75         perror("fclose");
  76         exit(EX_IOERR);
  77     }
  78
  79     /* We finally got it! */
  80     offset = strtoul(buffer, NULL, 10);
  81
  82     return offset;
  83 }
  84
  85 /** Write the pad offset to the given pad. */
  86 void write_offset(PAD *p, unsigned long offset)
  87 {
  88     FILE *ofp;
  89     char buffer[OFFSET_SIZE];
  90
  91     ofp = open_offset_file(p, "wt");
  92
  93     memset(buffer, 0, OFFSET_SIZE);
  94     snprintf(buffer, OFFSET_SIZE - 1, "%ld", offset);
  95     printf("buffer=%s\n", buffer);
  96     if (fwrite(buffer, strlen(buffer), 1, ofp) != 1) {
  97         fprintf(stderr, "write error saving offset %ld for %s\n", offset, p->local_filename);
  98         exit(EX_IOERR);
  99     }
 100
 101
 102     if (fclose(ofp) != 0) {
 103         fprintf(stderr, "error closing offset file for writing for %s\n", p->local_filename);
 104         perror("fclose");
 105         exit(EX_IOERR);
 106     }
 107 }
 108
 109 /** Load a pad file from disk, adding to 'pads' global. */
 110 void load_pad(char *local_filename)
 111 {
 112     FILE *fp;
 113     PAD *new_pad;
 114
 115     fp = fopen("/Volumes/Not Backed Up/otp/otp-dazzlement", "rb");
 116     if (!fp) {
 117         perror("fopen");
 118         exit(EXIT_FAILURE);
 119     }
 120
 121     new_pad = malloc(sizeof(PAD));
 122     if (!new_pad) {
 123         perror("malloc");
 124         exit(EX_UNAVAILABLE);
 125     }
 126
 127     new_pad->local_filename = strdup(local_filename);
 128     new_pad->name = strdup("dc"); /* TODO */
 129     new_pad->fp = fp;
 130     new_pad->next = NULL;
 131
 132     /* Add to linked list. */
 133     if (!pads) {
 134         pads = new_pad;
 135     } else {
 136         PAD *p, *tail;
 137
 138         /* Find tail */
 139         for (p = pads; p; p = p->next)
 140             tail = p;
 141         tail->next = new_pad;
 142     }
 143 }
 144
 145 /** Close all pads and free allocated memory. */
 146 void free_pads()
 147 {
 148     PAD *p, *next;
 149
 150     for (p = pads; p; p = next) {
 151         free(p->name);
 152         free(p->local_filename);
 153         fclose(p->fp);
 154         next = p->next;
 155         free(p);
 156     }
 157 }
 158
 159 void free_message(MESSAGE *msg)
 160 {
 161     free(msg->cipher_text);
 162     free(msg);
 163 }
 164
 165 /** Unpackage a message packaged for transport.
 166  *
 167  * Caller must free_message(). */
 168 MESSAGE *unpackage(char *input)
 169 {
 170     MESSAGE *msg;
 171     unsigned int at;
 172     char *s, *end;
 173
 174     msg = malloc(sizeof(MESSAGE));
 175     if (!msg) {
 176         perror("malloc");
 177         exit(EX_UNAVAILABLE);
 178     }
 179
 180     /** Format <v0.7 (pad name is unspecified; use default):
 181      * MARKER_BEGIN + offset + comma
 182      * base64'd data
 183      * MARKER_END
 184      *
 185      * Format >=0.7:
 186      * MARKER_BEGIN + offset + comma + pad_name + comma
 187      * base64'd data
 188      * MARKER_END
 189      */
 190
 191     at = 0;
 192
 193     /* Locate where the message begins. */
 194     s = strstr(input, MARKER_BEGIN);
 195     if (!s) {
 196         fprintf(stderr, "unpackage: input |%s| lacks beginning marker %s\n",
 197                 input, MARKER_BEGIN);
 198         exit(EX_DATAERR);
 199     }
 200
 201     /* ...and ends. */
 202     end = strstr(input, MARKER_END);
 203     if (!end) {
 204         fprintf(stderr, "unpackage: input |%s| lacks ending marker %s\n",
 205                 input, MARKER_END);
 206         exit(EX_DATAERR);
 207     }
 208
 209     s += strlen(MARKER_BEGIN);
 210     msg->offset = strtoul(s, &s, 10);
 211
 212     printf("offset=%ld\n", msg->offset);
 213
 214     /* Move after mandatory comma. */
 215     if (s[0] != ',') {
 216         fprintf(stderr, "unpackage: missing comma after offset, at |%s|, input |%s|\n",
 217                 s, input);
 218         exit(EX_DATAERR);
 219     }
 220     ++s;
 221
 222     memset(msg->pad_name, 0, PAD_NAME_LENGTH);
 223
 224     /* Includes pad name? */
 225     if (s[0] != '\n' && s[0] != '\r') {
 226         unsigned int i;
 227
 228         i = 0;
 229         /* v0.7+ message, includes pad name */
 230         while(s[0] != '\n' && s[0] != '\r' && s[0] != ',' && s < end) {
 231             msg->pad_name[i] = s[0];
 232             ++s;
 233             ++i;
 234             if (i > PAD_NAME_LENGTH) {
 235                 fprintf(stderr, "unpackage: pad name length > maximum %d, in input |%s|\n",
 236                         PAD_NAME_LENGTH, input);
 237                 exit(EX_DATAERR);
 238             }
 239         }
 240     }
 241
 242     printf("Pad name: |%s|\n", msg->pad_name);
 243
 244     /* Go to next line */
 245     while((s[0] == '\n' || s[0] == '\r' || s[0] == ',') && (s < end))
 246         ++s;
 247
 248     printf("s=%s\n", s);
 249
 250     /* Extract base64 data from end of message. */
 251     msg->cipher_text = strdup(s);
 252     msg->cipher_text[end - s] = 0;
 253
 254     printf("b64_data=<%s>\n", msg->cipher_text);
 255
 256     return msg;
 257 }
 258