crypt: Make base64_decode public.

gcrypt.c needs this to decode public rsa keys. Public functions
should always return proper error codes, so change the return
value for errors from -1 to -E_BASE64.

diff --git a/crypt_backend.h b/crypt_backend.h
index b362651dec3c76e5ecf643a5aea7c6ca435c0dad..3ea32c2045432d55ed34ad6ba1b29362b32c4d0c 100644 (file)
--- a/crypt_backend.h
+++ b/crypt_backend.h
@@ -13,3 +13,4 @@ uint32_t read_ssh_u32(const void *vp);
 int uudecode(const char *src, unsigned char *target, size_t targsize);
 int check_ssh_key_header(const unsigned char *blob, int blen);
 int check_key_file(const char *file, bool private_key);
+int base64_decode(char const *src, unsigned char *target, size_t targsize);

diff --git a/crypt_common.c b/crypt_common.c
index 1308af4148851246fbf328c2d4037a44dc43ac39..3bd603c0ec698ab6be9c3e48d99e7a76e52c53f0 100644 (file)
--- a/crypt_common.c
+++ b/crypt_common.c
@@ -57,10 +57,10 @@ static const char Pad64 = '=';
 /*
  * Skips all whitespace anywhere. Converts characters, four at a time, starting
  * at (or after) src from base - 64 numbers into three 8 bit bytes in the
- * target area. it returns the number of data bytes stored at the target, or -1
+ * target area. it returns the number of data bytes stored at the target, or -E_BASE64
  * on error.
  */
-static int base64_decode(char const *src, unsigned char *target, size_t targsize)
+int base64_decode(char const *src, unsigned char *target, size_t targsize)
 {
        unsigned int tarindex, state;
        int ch;
@@ -78,13 +78,13 @@ static int base64_decode(char const *src, unsigned char *target, size_t targsize
 
                pos = strchr(Base64, ch);
                if (pos == 0) /* A non-base64 character. */
-                       return -1;
+                       return -E_BASE64;
 
                switch (state) {
                case 0:
                        if (target) {
                                if (tarindex >= targsize)
-                                       return (-1);
+                                       return -E_BASE64;
                                target[tarindex] = (pos - Base64) << 2;
                        }
                        state = 1;
@@ -92,7 +92,7 @@ static int base64_decode(char const *src, unsigned char *target, size_t targsize
                case 1:
                        if (target) {
                                if (tarindex + 1 >= targsize)
-                                       return (-1);
+                                       return -E_BASE64;
                                target[tarindex]   |=  (pos - Base64) >> 4;
                                target[tarindex+1]  = ((pos - Base64) & 0x0f)
                                                        << 4 ;
@@ -103,7 +103,7 @@ static int base64_decode(char const *src, unsigned char *target, size_t targsize
                case 2:
                        if (target) {
                                if (tarindex + 1 >= targsize)
-                                       return (-1);
+                                       return -E_BASE64;
                                target[tarindex]   |=  (pos - Base64) >> 2;
                                target[tarindex+1]  = ((pos - Base64) & 0x03)
                                                        << 6;
@@ -114,7 +114,7 @@ static int base64_decode(char const *src, unsigned char *target, size_t targsize
                case 3:
                        if (target) {
                                if (tarindex >= targsize)
-                                       return (-1);
+                                       return -E_BASE64;
                                target[tarindex] |= (pos - Base64);
                        }
                        tarindex++;
@@ -133,7 +133,7 @@ static int base64_decode(char const *src, unsigned char *target, size_t targsize
                switch (state) {
                case 0:         /* Invalid = in first position */
                case 1:         /* Invalid = in second position */
-                       return (-1);
+                       return -E_BASE64;
 
                case 2:         /* Valid, means one byte of info */
                        /* Skip any number of spaces. */
@@ -142,7 +142,7 @@ static int base64_decode(char const *src, unsigned char *target, size_t targsize
                                        break;
                        /* Make sure there is another trailing = sign. */
                        if (ch != Pad64)
-                               return (-1);
+                               return -E_BASE64;
                        ch = *src++;            /* Skip the = */
                        /* Fall through to "single trailing =" case. */
                        /* FALLTHROUGH */
@@ -154,7 +154,7 @@ static int base64_decode(char const *src, unsigned char *target, size_t targsize
                         */
                        for (; ch != '\0'; ch = *src++)
                                if (!isspace(ch))
-                                       return (-1);
+                                       return -E_BASE64;
 
                        /*
                         * Now make sure for cases 2 and 3 that the "extra"
@@ -163,7 +163,7 @@ static int base64_decode(char const *src, unsigned char *target, size_t targsize
                         * subliminal channel.
                         */
                        if (target && target[tarindex] != 0)
-                               return (-1);
+                               return -E_BASE64;
                }
        } else {
                /*
@@ -171,10 +171,10 @@ static int base64_decode(char const *src, unsigned char *target, size_t targsize
                 * have no partial bytes lying around.
                 */
                if (state != 0)
-                       return (-1);
+                       return -E_BASE64;
        }
 
-       return (tarindex);
+       return tarindex;
 }
 
 int uudecode(const char *src, unsigned char *target, size_t targsize)
@@ -193,7 +193,7 @@ int uudecode(const char *src, unsigned char *target, size_t targsize)
        *p = '\0';
        len = base64_decode(encoded, target, targsize);
        free(encoded);
-       return len >= 0? len : -E_BASE64;
+       return len;
 }
 
 /*