Changeset 6009:15a15f6ae3a2 in nginx


Ignore:
Timestamp:
03/16/15 21:26:15 (5 years ago)
Author:
Ruslan Ermilov <ru@…>
Branch:
default
Phase:
public
Message:

Core: overflow detection in number parsing functions.

Location:
src/core
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • src/core/ngx_parse.c

    r4412 r6009  
    1313ngx_parse_size(ngx_str_t *line)
    1414{
    15     u_char     unit;
    16     size_t     len;
    17     ssize_t    size;
    18     ngx_int_t  scale;
     15    u_char   unit;
     16    size_t   len;
     17    ssize_t  size, scale, max;
    1918
    2019    len = line->len;
     
    2524    case 'k':
    2625        len--;
     26        max = NGX_MAX_SIZE_T_VALUE / 1024;
    2727        scale = 1024;
    2828        break;
     
    3131    case 'm':
    3232        len--;
     33        max = NGX_MAX_SIZE_T_VALUE / (1024 * 1024);
    3334        scale = 1024 * 1024;
    3435        break;
    3536
    3637    default:
     38        max = NGX_MAX_SIZE_T_VALUE;
    3739        scale = 1;
    3840    }
    3941
    4042    size = ngx_atosz(line->data, len);
    41     if (size == NGX_ERROR) {
     43    if (size == NGX_ERROR || size > max) {
    4244        return NGX_ERROR;
    4345    }
     
    5254ngx_parse_offset(ngx_str_t *line)
    5355{
    54     u_char     unit;
    55     off_t      offset;
    56     size_t     len;
    57     ngx_int_t  scale;
     56    u_char  unit;
     57    off_t   offset, scale, max;
     58    size_t  len;
    5859
    5960    len = line->len;
     
    6465    case 'k':
    6566        len--;
     67        max = NGX_MAX_OFF_T_VALUE / 1024;
    6668        scale = 1024;
    6769        break;
     
    7072    case 'm':
    7173        len--;
     74        max = NGX_MAX_OFF_T_VALUE / (1024 * 1024);
    7275        scale = 1024 * 1024;
    7376        break;
     
    7679    case 'g':
    7780        len--;
     81        max = NGX_MAX_OFF_T_VALUE / (1024 * 1024 * 1024);
    7882        scale = 1024 * 1024 * 1024;
    7983        break;
    8084
    8185    default:
     86        max = NGX_MAX_OFF_T_VALUE;
    8287        scale = 1;
    8388    }
    8489
    8590    offset = ngx_atoof(line->data, len);
    86     if (offset == NGX_ERROR) {
     91    if (offset == NGX_ERROR || offset > max) {
    8792        return NGX_ERROR;
    8893    }
  • src/core/ngx_string.c

    r5965 r6009  
    902902ngx_atoi(u_char *line, size_t n)
    903903{
    904     ngx_int_t  value;
     904    ngx_int_t  value, cutoff, cutlim;
    905905
    906906    if (n == 0) {
    907907        return NGX_ERROR;
    908908    }
     909
     910    cutoff = NGX_MAX_INT_T_VALUE / 10;
     911    cutlim = NGX_MAX_INT_T_VALUE % 10;
    909912
    910913    for (value = 0; n--; line++) {
     
    913916        }
    914917
     918        if (value >= cutoff && (value > cutoff || *line - '0' > cutlim)) {
     919            return NGX_ERROR;
     920        }
     921
    915922        value = value * 10 + (*line - '0');
    916923    }
    917924
    918     if (value < 0) {
    919         return NGX_ERROR;
    920 
    921     } else {
    922         return value;
    923     }
     925    return value;
    924926}
    925927
     
    930932ngx_atofp(u_char *line, size_t n, size_t point)
    931933{
    932     ngx_int_t   value;
     934    ngx_int_t   value, cutoff, cutlim;
    933935    ngx_uint_t  dot;
    934936
     
    936938        return NGX_ERROR;
    937939    }
     940
     941    cutoff = NGX_MAX_INT_T_VALUE / 10;
     942    cutlim = NGX_MAX_INT_T_VALUE % 10;
    938943
    939944    dot = 0;
     
    958963        }
    959964
     965        if (value >= cutoff && (value > cutoff || *line - '0' > cutlim)) {
     966            return NGX_ERROR;
     967        }
     968
    960969        value = value * 10 + (*line - '0');
    961970        point -= dot;
     
    963972
    964973    while (point--) {
     974        if (value > cutoff) {
     975            return NGX_ERROR;
     976        }
     977
    965978        value = value * 10;
    966979    }
    967980
    968     if (value < 0) {
    969         return NGX_ERROR;
    970 
    971     } else {
    972         return value;
    973     }
     981    return value;
    974982}
    975983
     
    978986ngx_atosz(u_char *line, size_t n)
    979987{
    980     ssize_t  value;
     988    ssize_t  value, cutoff, cutlim;
    981989
    982990    if (n == 0) {
    983991        return NGX_ERROR;
    984992    }
     993
     994    cutoff = NGX_MAX_SIZE_T_VALUE / 10;
     995    cutlim = NGX_MAX_SIZE_T_VALUE % 10;
    985996
    986997    for (value = 0; n--; line++) {
     
    9891000        }
    9901001
     1002        if (value >= cutoff && (value > cutoff || *line - '0' > cutlim)) {
     1003            return NGX_ERROR;
     1004        }
     1005
    9911006        value = value * 10 + (*line - '0');
    9921007    }
    9931008
    994     if (value < 0) {
    995         return NGX_ERROR;
    996 
    997     } else {
    998         return value;
    999     }
     1009    return value;
    10001010}
    10011011
     
    10041014ngx_atoof(u_char *line, size_t n)
    10051015{
    1006     off_t  value;
     1016    off_t  value, cutoff, cutlim;
    10071017
    10081018    if (n == 0) {
    10091019        return NGX_ERROR;
    10101020    }
     1021
     1022    cutoff = NGX_MAX_OFF_T_VALUE / 10;
     1023    cutlim = NGX_MAX_OFF_T_VALUE % 10;
    10111024
    10121025    for (value = 0; n--; line++) {
     
    10151028        }
    10161029
     1030        if (value >= cutoff && (value > cutoff || *line - '0' > cutlim)) {
     1031            return NGX_ERROR;
     1032        }
     1033
    10171034        value = value * 10 + (*line - '0');
    10181035    }
    10191036
    1020     if (value < 0) {
    1021         return NGX_ERROR;
    1022 
    1023     } else {
    1024         return value;
    1025     }
     1037    return value;
    10261038}
    10271039
     
    10301042ngx_atotm(u_char *line, size_t n)
    10311043{
    1032     time_t  value;
     1044    time_t  value, cutoff, cutlim;
    10331045
    10341046    if (n == 0) {
    10351047        return NGX_ERROR;
    10361048    }
     1049
     1050    cutoff = NGX_MAX_TIME_T_VALUE / 10;
     1051    cutlim = NGX_MAX_TIME_T_VALUE % 10;
    10371052
    10381053    for (value = 0; n--; line++) {
     
    10411056        }
    10421057
     1058        if (value >= cutoff && (value > cutoff || *line - '0' > cutlim)) {
     1059            return NGX_ERROR;
     1060        }
     1061
    10431062        value = value * 10 + (*line - '0');
    10441063    }
    10451064
    1046     if (value < 0) {
    1047         return NGX_ERROR;
    1048 
    1049     } else {
    1050         return value;
    1051     }
     1065    return value;
    10521066}
    10531067
     
    10571071{
    10581072    u_char     c, ch;
    1059     ngx_int_t  value;
     1073    ngx_int_t  value, cutoff;
    10601074
    10611075    if (n == 0) {
     
    10631077    }
    10641078
     1079    cutoff = NGX_MAX_INT_T_VALUE / 16;
     1080
    10651081    for (value = 0; n--; line++) {
     1082        if (value > cutoff) {
     1083            return NGX_ERROR;
     1084        }
     1085
    10661086        ch = *line;
    10671087
     
    10811101    }
    10821102
    1083     if (value < 0) {
    1084         return NGX_ERROR;
    1085 
    1086     } else {
    1087         return value;
    1088     }
     1103    return value;
    10891104}
    10901105
Note: See TracChangeset for help on using the changeset viewer.