source: patches/perl-5.8.8-security_fixes-1.patch@ f41b9d0

clfs-1.2 clfs-2.1 clfs-3.0.0-systemd clfs-3.0.0-sysvinit systemd sysvinit
Last change on this file since f41b9d0 was f41b9d0, checked in by Ken Moffat <zarniwhoop@…>, 16 years ago

Add patch to fix known perl vulnerabilities.

  • Property mode set to 100644
File size: 10.0 KB
  • embed.fnc

    Submitted By: Ken Moffat <ken at linuxfromscratch dot org>
    Date: 2008-07-09
    Initial Package Version: 5.8.8
    Upstream Status: unknown
    Origin: Extracted from redhat-enterprise.
    Description: Fixes CVE-2007-5116 and CVE-2008-1927.  NB - anyone who
    thinks we should just upgrade to 5.10.0 needs to find a fix for
    CVE-2008-2827 : no doubt 5.10.1 will fix that when it is released.
    Edited to remove the creation of regcomp.c~ which I had overlooked.
    
    diff -Naur perl-5.8.8.orig/embed.fnc perl-5.8.8/embed.fnc
    old new  
    11681168Es      |regnode*|regclass      |NN struct RExC_state_t *state
    11691169ERs     |I32    |regcurly       |NN const char *
    11701170Es      |regnode*|reg_node      |NN struct RExC_state_t *state|U8 op
     1171Es      |UV     |reg_recode     |const char value|NULLOK SV **encp
    11711172Es      |regnode*|regpiece      |NN struct RExC_state_t *state|NN I32 *flagp
    11721173Es      |void   |reginsert      |NN struct RExC_state_t *state|U8 op|NN regnode *opnd
    11731174Es      |void   |regoptail      |NN struct RExC_state_t *state|NN regnode *p|NN regnode *val
  • perl-5.8.8

    diff -Naur perl-5.8.8.orig/embed.h perl-5.8.8/embed.h
    old new  
    12341234#define regclass                S_regclass
    12351235#define regcurly                S_regcurly
    12361236#define reg_node                S_reg_node
     1237#define reg_recode              S_reg_recode
    12371238#define regpiece                S_regpiece
    12381239#define reginsert               S_reginsert
    12391240#define regoptail               S_regoptail
     
    32773278#define regclass(a)             S_regclass(aTHX_ a)
    32783279#define regcurly(a)             S_regcurly(aTHX_ a)
    32793280#define reg_node(a,b)           S_reg_node(aTHX_ a,b)
     3281#define reg_recode(a,b)         S_reg_recode(aTHX_ a,b)
    32803282#define regpiece(a,b)           S_regpiece(aTHX_ a,b)
    32813283#define reginsert(a,b,c)        S_reginsert(aTHX_ a,b,c)
    32823284#define regoptail(a,b,c)        S_regoptail(aTHX_ a,b,c)
  • pod/perldiag.pod

    diff -Naur perl-5.8.8.orig/pod/perldiag.pod perl-5.8.8/pod/perldiag.pod
    old new  
    19001900(W printf) Perl does not understand the given format conversion.  See
    19011901L<perlfunc/sprintf>.
    19021902
     1903=item Invalid escape in the specified encoding in regex; marked by <-- HERE in m/%s/
     1904
     1905(W regexp) The numeric escape (for example C<\xHH>) of value < 256
     1906didn't correspond to a single character through the conversion
     1907from the encoding specified by the encoding pragma.
     1908The escape was replaced with REPLACEMENT CHARACTER (U+FFFD) instead.
     1909The <-- HERE shows in the regular expression about where the
     1910escape was discovered.
     1911
    19031912=item Invalid [] range "%s" in regex; marked by <-- HERE in m/%s/
    19041913
    19051914(F) The range specified in a character class had a minimum character
  • perl-5.8.8

    diff -Naur perl-5.8.8.orig/proto.h perl-5.8.8/proto.h
    old new  
    17481748                        __attribute__warn_unused_result__;
    17491749
    17501750STATIC regnode* S_reg_node(pTHX_ struct RExC_state_t *state, U8 op);
     1751STATIC UV       S_reg_recode(pTHX_ const char value, SV **encp);
    17511752STATIC regnode* S_regpiece(pTHX_ struct RExC_state_t *state, I32 *flagp);
    17521753STATIC void     S_reginsert(pTHX_ struct RExC_state_t *state, U8 op, regnode *opnd);
    17531754STATIC void     S_regoptail(pTHX_ struct RExC_state_t *state, regnode *p, regnode *val);
  • regcomp.c

    diff -Naur perl-5.8.8.orig/regcomp.c perl-5.8.8/regcomp.c
    old new  
    136136    I32         seen_zerolen;
    137137    I32         seen_evals;
    138138    I32         utf8;
     139    I32         orig_utf8;
    139140#if ADD_TO_REGEXEC
    140141    char        *starttry;              /* -Dr: where regtry was called. */
    141142#define RExC_starttry   (pRExC_state->starttry)
     
    161162#define RExC_seen_zerolen       (pRExC_state->seen_zerolen)
    162163#define RExC_seen_evals (pRExC_state->seen_evals)
    163164#define RExC_utf8       (pRExC_state->utf8)
     165#define RExC_orig_utf8 (pRExC_state->orig_utf8)
    164166
    165167#define ISMULT1(c)      ((c) == '*' || (c) == '+' || (c) == '?')
    166168#define ISMULT2(s)      ((*s) == '*' || (*s) == '+' || (*s) == '?' || \
     
    17491751    if (exp == NULL)
    17501752        FAIL("NULL regexp argument");
    17511753
    1752     RExC_utf8 = pm->op_pmdynflags & PMdf_CMP_UTF8;
     1754    RExC_orig_utf8 = RExC_utf8 = pm->op_pmdynflags & PMdf_CMP_UTF8;
    17531755
    1754     RExC_precomp = exp;
    17551756    DEBUG_r({
    17561757         if (!PL_colorset) reginitcolors();
    17571758         PerlIO_printf(Perl_debug_log, "%sCompiling REx%s `%s%*s%s'\n",
    17581759                       PL_colors[4],PL_colors[5],PL_colors[0],
    1759                        (int)(xend - exp), RExC_precomp, PL_colors[1]);
     1760                       (int)(xend - exp), exp, PL_colors[1]);
    17601761    });
     1762
     1763redo_first_pass:
     1764    RExC_precomp = exp;
    17611765    RExC_flags = pm->op_pmflags;
    17621766    RExC_sawback = 0;
    17631767
     
    17831787        RExC_precomp = Nullch;
    17841788        return(NULL);
    17851789    }
     1790    if (RExC_utf8 && !RExC_orig_utf8) {
     1791        STRLEN len = xend-exp;
     1792        DEBUG_r(PerlIO_printf(Perl_debug_log,
     1793           "UTF8 mismatch! Converting to utf8 for resizing and compile\n"));
     1794        exp = (char*)Perl_bytes_to_utf8(aTHX_ (U8*)exp, &len);
     1795        xend = exp + len;
     1796        RExC_orig_utf8 = RExC_utf8;
     1797        SAVEFREEPV(exp);
     1798        goto redo_first_pass;
     1799    }
     1800
    17861801    DEBUG_r(PerlIO_printf(Perl_debug_log, "size %"IVdf" ", (IV)RExC_size));
    17871802
    17881803    /* Small enough for pointer-storage convention?
     
    27752790}
    27762791
    27772792/*
     2793 * reg_recode
     2794 *
     2795 * It returns the code point in utf8 for the value in *encp.
     2796 *    value: a code value in the source encoding
     2797 *    encp:  a pointer to an Encode object
     2798 *
     2799 * If the result from Encode is not a single character,
     2800 * it returns U+FFFD (Replacement character) and sets *encp to NULL.
     2801 */
     2802STATIC UV
     2803S_reg_recode(pTHX_ const char value, SV **encp)
     2804{
     2805    STRLEN numlen = 1;
     2806    SV * const sv = sv_2mortal(newSVpvn(&value, numlen));
     2807    const char * const s = encp && *encp ? sv_recode_to_utf8(sv, *encp)
     2808                                         : SvPVX(sv);
     2809    const STRLEN newlen = SvCUR(sv);
     2810    UV uv = UNICODE_REPLACEMENT;
     2811
     2812    if (newlen)
     2813        uv = SvUTF8(sv)
     2814             ? utf8n_to_uvchr((U8*)s, newlen, &numlen, UTF8_ALLOW_DEFAULT)
     2815             : *(U8*)s;
     2816
     2817    if (!newlen || numlen != newlen) {
     2818        uv = UNICODE_REPLACEMENT;
     2819        if (encp)
     2820            *encp = NULL;
     2821    }
     2822    return uv;
     2823}
     2824
     2825/*
    27782826 - regatom - the lowest level
    27792827 *
    27802828 * Optimization:  gobbles an entire sequence of ordinary characters so that
     
    31663214                            ender = grok_hex(p, &numlen, &flags, NULL);
    31673215                            p += numlen;
    31683216                        }
     3217                        if (PL_encoding && ender < 0x100)
     3218                            goto recode_encoding;
    31693219                        break;
    31703220                    case 'c':
    31713221                        p++;
     
    31853235                            --p;
    31863236                            goto loopdone;
    31873237                        }
     3238                        if (PL_encoding && ender < 0x100)
     3239                            goto recode_encoding;
     3240                        break;
     3241                    recode_encoding:
     3242                        {
     3243                            SV* enc = PL_encoding;
     3244                            ender = reg_recode((const char)(U8)ender, &enc);
     3245                            if (!enc && SIZE_ONLY && ckWARN(WARN_REGEXP))
     3246                                vWARN(p, "Invalid escape in the specified encoding");
     3247                            RExC_utf8 = 1;
     3248                        }
    31883249                        break;
    31893250                    case '\0':
    31903251                        if (p >= RExC_end)
     
    33153376        break;
    33163377    }
    33173378
    3318     /* If the encoding pragma is in effect recode the text of
    3319      * any EXACT-kind nodes. */
    3320     if (PL_encoding && PL_regkind[(U8)OP(ret)] == EXACT) {
    3321         STRLEN oldlen = STR_LEN(ret);
    3322         SV *sv        = sv_2mortal(newSVpvn(STRING(ret), oldlen));
    3323 
    3324         if (RExC_utf8)
    3325             SvUTF8_on(sv);
    3326         if (sv_utf8_downgrade(sv, TRUE)) {
    3327             const char * const s = sv_recode_to_utf8(sv, PL_encoding);
    3328             const STRLEN newlen = SvCUR(sv);
    3329 
    3330             if (SvUTF8(sv))
    3331                 RExC_utf8 = 1;
    3332             if (!SIZE_ONLY) {
    3333                 DEBUG_r(PerlIO_printf(Perl_debug_log, "recode %*s to %*s\n",
    3334                                       (int)oldlen, STRING(ret),
    3335                                       (int)newlen, s));
    3336                 Copy(s, STRING(ret), newlen, char);
    3337                 STR_LEN(ret) += newlen - oldlen;
    3338                 RExC_emit += STR_SZ(newlen) - STR_SZ(oldlen);
    3339             } else
    3340                 RExC_size += STR_SZ(newlen) - STR_SZ(oldlen);
    3341         }
    3342     }
    3343 
    33443379    return(ret);
    33453380}
    33463381
     
    37183753                    value = grok_hex(RExC_parse, &numlen, &flags, NULL);
    37193754                    RExC_parse += numlen;
    37203755                }
     3756                if (PL_encoding && value < 0x100)
     3757                    goto recode_encoding;
    37213758                break;
    37223759            case 'c':
    37233760                value = UCHARAT(RExC_parse++);
     
    37253762                break;
    37263763            case '0': case '1': case '2': case '3': case '4':
    37273764            case '5': case '6': case '7': case '8': case '9':
    3728             {
    3729                 I32 flags = 0;
    3730                 numlen = 3;
    3731                 value = grok_oct(--RExC_parse, &numlen, &flags, NULL);
    3732                 RExC_parse += numlen;
    3733                 break;
    3734             }
     3765                {
     3766                    I32 flags = 0;
     3767                    numlen = 3;
     3768                    value = grok_oct(--RExC_parse, &numlen, &flags, NULL);
     3769                    RExC_parse += numlen;
     3770                    if (PL_encoding && value < 0x100)
     3771                        goto recode_encoding;
     3772                    break;
     3773                }
     3774            recode_encoding:
     3775                {
     3776                    SV* enc = PL_encoding;
     3777                    value = reg_recode((const char)(U8)value, &enc);
     3778                    if (!enc && SIZE_ONLY && ckWARN(WARN_REGEXP))
     3779                        vWARN(RExC_parse,
     3780                              "Invalid escape in the specified encoding");
     3781                    break;
     3782                }
    37353783            default:
    37363784                if (!SIZE_ONLY && isALPHA(value) && ckWARN(WARN_REGEXP))
    37373785                    vWARN2(RExC_parse,
  • t/uni/tr_utf8.t

    diff -Naur perl-5.8.8.orig/t/uni/tr_utf8.t perl-5.8.8/t/uni/tr_utf8.t
    old new  
    3131}
    3232
    3333use strict;
    34 use Test::More tests => 7;
     34use Test::More tests => 8;
    3535
    3636use encoding 'utf8';
    3737
     
    6767  $line =~ tr/bcdeghijklmnprstvwxyz$02578/ב׊דעגהיײקלמנ׀֌ךסטװשכיזשױתײחא/;
    6868  is($line, "aב׊דעfגהיײקלמנo×€q֌ךסuטװשכיזש1×±34ת6ײח9", "[perl #16843]");
    6969}
     70
     71{
     72  # [perl #40641]
     73  my $str = qq/GebÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀude/;
     74  my $reg = qr/GebÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀude/;
     75  ok($str =~ /$reg/, "[perl #40641]");
     76}
     77
    7078__END__
  • perl-5.8.8

    diff -Naur perl-5.8.8.orig/utf8.h perl-5.8.8/utf8.h
    old new  
    198198                                         UTF8_ALLOW_SURROGATE|UTF8_ALLOW_FFFF)
    199199#define UTF8_ALLOW_ANY                  0x00FF
    200200#define UTF8_CHECK_ONLY                 0x0200
     201#define UTF8_ALLOW_DEFAULT             (ckWARN(WARN_UTF8) ? 0 : \
     202                                        UTF8_ALLOW_ANYUV)
    201203
    202204#define UNICODE_SURROGATE_FIRST         0xD800
    203205#define UNICODE_SURROGATE_LAST          0xDFFF
Note: See TracBrowser for help on using the repository browser.