source: branches/backfire/package/busybox/patches/004-upstream-percent_decode_in_place.patch @ 29322

Last change on this file since 29322 was 29322, checked in by nico, 4 years ago

[backfire] package/busybox: add patch missing from r29315 (oops)

File size: 5.5 KB
  • include/libbb.h

    a b pid_t *find_pid_by_name(const char* proc 
    13681368pid_t *pidlist_reverse(pid_t *pidList) FAST_FUNC; 
    13691369 
    13701370 
     1371/* Use strict=1 if you process input from untrusted source: 
     1372 * it will return NULL on invalid %xx (bad hex chars) 
     1373 * and str + 1 if decoded char is / or NUL. 
     1374 * In non-strict mode, it always succeeds (returns str), 
     1375 * and also it additionally decoded '+' to space. 
     1376 */ 
     1377char *percent_decode_in_place(char *str, int strict) FAST_FUNC; 
     1378 
     1379 
    13711380extern const char bb_uuenc_tbl_base64[]; 
    13721381extern const char bb_uuenc_tbl_std[]; 
    13731382void bb_uuencode(char *store, const void *s, int length, const char *tbl) FAST_FUNC; 
  • libbb/Kbuild

    a b lib-y += mtab_file.o 
    6666lib-y += obscure.o 
    6767lib-y += parse_mode.o 
    6868lib-y += parse_config.o 
     69lib-y += percent_decode.o 
    6970lib-y += perror_msg.o 
    7071lib-y += perror_msg_and_die.o 
    7172lib-y += perror_nomsg.o 
  • new file libbb/percent_decode.c

    - +  
     1/* vi: set sw=4 ts=4: */ 
     2/* 
     3 * Licensed under GPLv2 or later, see file LICENSE in this source tree. 
     4 */ 
     5 
     6//kbuild:lib-y += percent_decode.o 
     7 
     8#include "libbb.h" 
     9 
     10static unsigned hex_to_bin(unsigned char c) 
     11{ 
     12        unsigned v; 
     13 
     14        v = c - '0'; 
     15        if (v <= 9) 
     16                return v; 
     17        /* c | 0x20: letters to lower case, non-letters 
     18         * to (potentially different) non-letters */ 
     19        v = (unsigned)(c | 0x20) - 'a'; 
     20        if (v <= 5) 
     21                return v + 10; 
     22        return ~0; 
     23/* For testing: 
     24void t(char c) { printf("'%c'(%u) %u\n", c, c, hex_to_bin(c)); } 
     25int main() { t(0x10); t(0x20); t('0'); t('9'); t('A'); t('F'); t('a'); t('f'); 
     26t('0'-1); t('9'+1); t('A'-1); t('F'+1); t('a'-1); t('f'+1); return 0; } 
     27*/ 
     28} 
     29 
     30char* FAST_FUNC percent_decode_in_place(char *str, int strict) 
     31{ 
     32        /* note that decoded string is always shorter than original */ 
     33        char *src = str; 
     34        char *dst = str; 
     35        char c; 
     36 
     37        while ((c = *src++) != '\0') { 
     38                unsigned v; 
     39 
     40                if (!strict && c == '+') { 
     41                        *dst++ = ' '; 
     42                        continue; 
     43                } 
     44                if (c != '%') { 
     45                        *dst++ = c; 
     46                        continue; 
     47                } 
     48                v = hex_to_bin(src[0]); 
     49                if (v > 15) { 
     50 bad_hex: 
     51                        if (strict) 
     52                                return NULL; 
     53                        *dst++ = '%'; 
     54                        continue; 
     55                } 
     56                v = (v * 16) | hex_to_bin(src[1]); 
     57                if (v > 255) 
     58                        goto bad_hex; 
     59                if (strict && (v == '/' || v == '\0')) { 
     60                        /* caller takes it as indication of invalid 
     61                         * (dangerous wrt exploits) chars */ 
     62                        return str + 1; 
     63                } 
     64                *dst++ = v; 
     65                src += 2; 
     66        } 
     67        *dst = '\0'; 
     68        return str; 
     69} 
  • networking/httpd.c

    a b static char *encodeString(const char *st 
    785785} 
    786786#endif          /* FEATURE_HTTPD_ENCODE_URL_STR */ 
    787787 
    788 /* 
    789  * Given a URL encoded string, convert it to plain ascii. 
    790  * Since decoding always makes strings smaller, the decode is done in-place. 
    791  * Thus, callers should xstrdup() the argument if they do not want the 
    792  * argument modified.  The return is the original pointer, allowing this 
    793  * function to be easily used as arguments to other functions. 
    794  * 
    795  * string    The first string to decode. 
    796  * option_d  1 if called for httpd -d 
    797  * 
    798  * Returns a pointer to the decoded string (same as input). 
    799  */ 
    800 static unsigned hex_to_bin(unsigned char c) 
    801 { 
    802         unsigned v; 
    803  
    804         v = c - '0'; 
    805         if (v <= 9) 
    806                 return v; 
    807         /* c | 0x20: letters to lower case, non-letters 
    808          * to (potentially different) non-letters */ 
    809         v = (unsigned)(c | 0x20) - 'a'; 
    810         if (v <= 5) 
    811                 return v + 10; 
    812         return ~0; 
    813 } 
    814 /* For testing: 
    815 void t(char c) { printf("'%c'(%u) %u\n", c, c, hex_to_bin(c)); } 
    816 int main() { t(0x10); t(0x20); t('0'); t('9'); t('A'); t('F'); t('a'); t('f'); 
    817 t('0'-1); t('9'+1); t('A'-1); t('F'+1); t('a'-1); t('f'+1); return 0; } 
    818 */ 
    819 static char *decodeString(char *orig, int option_d) 
    820 { 
    821         /* note that decoded string is always shorter than original */ 
    822         char *string = orig; 
    823         char *ptr = string; 
    824         char c; 
    825  
    826         while ((c = *ptr++) != '\0') { 
    827                 unsigned v; 
    828  
    829                 if (option_d && c == '+') { 
    830                         *string++ = ' '; 
    831                         continue; 
    832                 } 
    833                 if (c != '%') { 
    834                         *string++ = c; 
    835                         continue; 
    836                 } 
    837                 v = hex_to_bin(ptr[0]); 
    838                 if (v > 15) { 
    839  bad_hex: 
    840                         if (!option_d) 
    841                                 return NULL; 
    842                         *string++ = '%'; 
    843                         continue; 
    844                 } 
    845                 v = (v * 16) | hex_to_bin(ptr[1]); 
    846                 if (v > 255) 
    847                         goto bad_hex; 
    848                 if (!option_d && (v == '/' || v == '\0')) { 
    849                         /* caller takes it as indication of invalid 
    850                          * (dangerous wrt exploits) chars */ 
    851                         return orig + 1; 
    852                 } 
    853                 *string++ = v; 
    854                 ptr += 2; 
    855         } 
    856         *string = '\0'; 
    857         return orig; 
    858 } 
    859  
    860788#if ENABLE_FEATURE_HTTPD_BASIC_AUTH 
    861789/* 
    862790 * Decode a base64 data stream as per rfc1521. 
    static void handle_incoming_and_exit(con 
    18761804        } 
    18771805 
    18781806        /* Decode URL escape sequences */ 
    1879         tptr = decodeString(urlcopy, 0); 
     1807        tptr = percent_decode_in_place(urlcopy, /*strict:*/ 1); 
    18801808        if (tptr == NULL) 
    18811809                send_headers_and_exit(HTTP_BAD_REQUEST); 
    18821810        if (tptr == urlcopy + 1) { 
    int httpd_main(int argc UNUSED_PARAM, ch 
    23192247                        , &verbose 
    23202248                ); 
    23212249        if (opt & OPT_DECODE_URL) { 
    2322                 fputs(decodeString(url_for_decode, 1), stdout); 
     2250                fputs(percent_decode_in_place(url_for_decode, /*strict:*/ 0), stdout); 
    23232251                return 0; 
    23242252        } 
    23252253#if ENABLE_FEATURE_HTTPD_ENCODE_URL_STR 
  • networking/wget.c

    a b static void parse_url(char *src_url, str 
    373373        sp = strrchr(h->host, '@'); 
    374374        h->user = NULL; 
    375375        if (sp != NULL) { 
    376                 h->user = h->host; 
     376                // URL-decode "user:password" string before base64-encoding: 
     377                // wget http://test:my%20pass@example.com should send 
     378                // Authorization: Basic dGVzdDpteSBwYXNz 
     379                // which decodes to "test:my pass". 
     380                // Standard wget and curl do this too. 
    377381                *sp = '\0'; 
     382                h->user = percent_decode_in_place(h->host, /*strict:*/ 0); 
    378383                h->host = sp + 1; 
    379384        } 
    380385 
Note: See TracBrowser for help on using the repository browser.