contrib/libarchive/libarchive/archive_read_add_passphrase.c

   1 /*-
   2  * Copyright (c) 2014 Michihiro NAKAJIMA
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "archive_platform.h"
  27 __FBSDID("$FreeBSD$");
  28
  29 #ifdef HAVE_ERRNO_H
  30 #include <errno.h>
  31 #endif
  32 #include "archive_read_private.h"
  33
  34 static void
  35 add_passphrase_to_tail(struct archive_read *a,
  36     struct archive_read_passphrase *p)
  37 {
  38         *a->passphrases.last = p;
  39         a->passphrases.last = &p->next;
  40         p->next = NULL;
  41 }
  42
  43 static struct archive_read_passphrase *
  44 remove_passphrases_from_head(struct archive_read *a)
  45 {
  46         struct archive_read_passphrase *p;
  47
  48         p = a->passphrases.first;
  49         if (p != NULL)
  50                 a->passphrases.first = p->next;
  51         return (p);
  52 }
  53
  54 static void
  55 insert_passphrase_to_head(struct archive_read *a,
  56     struct archive_read_passphrase *p)
  57 {
  58         p->next = a->passphrases.first;
  59         a->passphrases.first = p;
  60         if (&a->passphrases.first == a->passphrases.last) {
  61                 a->passphrases.last = &p->next;
  62                 p->next = NULL;
  63         }
  64 }
  65
  66 static struct archive_read_passphrase *
  67 new_read_passphrase(struct archive_read *a, const char *passphrase)
  68 {
  69         struct archive_read_passphrase *p;
  70
  71         p = malloc(sizeof(*p));
  72         if (p == NULL) {
  73                 archive_set_error(&a->archive, ENOMEM,
  74                     "Can't allocate memory");
  75                 return (NULL);
  76         }
  77         p->passphrase = strdup(passphrase);
  78         if (p->passphrase == NULL) {
  79                 free(p);
  80                 archive_set_error(&a->archive, ENOMEM,
  81                     "Can't allocate memory");
  82                 return (NULL);
  83         }
  84         return (p);
  85 }
  86
  87 int
  88 archive_read_add_passphrase(struct archive *_a, const char *passphrase)
  89 {
  90         struct archive_read *a = (struct archive_read *)_a;
  91         struct archive_read_passphrase *p;
  92
  93         archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
  94                 "archive_read_add_passphrase");
  95
  96         if (passphrase == NULL || passphrase[0] == '\0') {
  97                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
  98                     "Empty passphrase is unacceptable");
  99                 return (ARCHIVE_FAILED);
 100         }
 101
 102         p = new_read_passphrase(a, passphrase);
 103         if (p == NULL)
 104                 return (ARCHIVE_FATAL);
 105         add_passphrase_to_tail(a, p);
 106
 107         return (ARCHIVE_OK);
 108 }
 109
 110 int
 111 archive_read_set_passphrase_callback(struct archive *_a, void *client_data,
 112     archive_passphrase_callback *cb)
 113 {
 114         struct archive_read *a = (struct archive_read *)_a;
 115
 116         archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
 117                 "archive_read_set_passphrase_callback");
 118
 119         a->passphrases.callback = cb;
 120         a->passphrases.client_data = client_data;
 121         return (ARCHIVE_OK);
 122 }
 123
 124 /*
 125  * Call this in advance when you start to get a passphrase for decryption
 126  * for a entry.
 127  */
 128 void
 129 __archive_read_reset_passphrase(struct archive_read *a)
 130 {
 131
 132         a->passphrases.candidate = -1;
 133 }
 134
 135 /*
 136  * Get a passphrase for decryption.
 137  */
 138 const char *
 139 __archive_read_next_passphrase(struct archive_read *a)
 140 {
 141         struct archive_read_passphrase *p;
 142         const char *passphrase;
 143
 144         if (a->passphrases.candidate < 0) {
 145                 /* Count out how many passphrases we have. */
 146                 int cnt = 0;
 147
 148                 for (p = a->passphrases.first; p != NULL; p = p->next)
 149                         cnt++;
 150                 a->passphrases.candidate = cnt;
 151                 p = a->passphrases.first;
 152         } else if (a->passphrases.candidate > 1) {
 153                 /* Rotate a passphrase list. */
 154                 a->passphrases.candidate--;
 155                 p = remove_passphrases_from_head(a);
 156                 add_passphrase_to_tail(a, p);
 157                 /* Pick a new passphrase candidate up. */
 158                 p = a->passphrases.first;
 159         } else if (a->passphrases.candidate == 1) {
 160                 /* This case is that all candidates failed to decrypt. */
 161                 a->passphrases.candidate = 0;
 162                 if (a->passphrases.first->next != NULL) {
 163                         /* Rotate a passphrase list. */
 164                         p = remove_passphrases_from_head(a);
 165                         add_passphrase_to_tail(a, p);
 166                 }
 167                 p = NULL;
 168         } else  /* There is no passphrase candidate. */
 169                 p = NULL;
 170
 171         if (p != NULL)
 172                 passphrase = p->passphrase;
 173         else if (a->passphrases.callback != NULL) {
 174                 /* Get a passphrase through a call-back function
 175                  * since we tried all passphrases out or we don't
 176                  * have it. */
 177                 passphrase = a->passphrases.callback(&a->archive,
 178                     a->passphrases.client_data);
 179                 if (passphrase != NULL) {
 180                         p = new_read_passphrase(a, passphrase);
 181                         if (p == NULL)
 182                                 return (NULL);
 183                         insert_passphrase_to_head(a, p);
 184                         a->passphrases.candidate = 1;
 185                 }
 186         } else
 187                 passphrase = NULL;
 188
 189         return (passphrase);
 190 }