← Back to branch summary

~ubuntu-branches/ubuntu/quantal/samba/quantal

« back to all changes in this revision

Viewing changes to debian/patches/CVE-2012-1182-1.patch

  • Committer: Package Import Robot
  • Author(s): Tyler Hicks
  • Date: 2012-04-12 05:28:44 UTC
  • Revision ID: package-import@ubuntu.com-20120412052844-i2u39y7vkrcx61u4
Tags: 2:3.6.3-2ubuntu2
https://launchpad.net/bugs/978458
* SECURITY UPDATE: Unauthenticated remote code execution via
  RPC calls (LP: #978458)
  - debian/patches/CVE-2012-1182-1.patch: Fix PIDL compiler to generate code
    that uses the same value for array allocation and array length checks.
    Based on upstream patch.
  - debian/patches/CVE-2012-1182-2.patch: Regenerate PIDL generated files
    with the patched PIDL compiler
  - CVE-2012-1182

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/patches/CVE-2012-1182-1.patch
 
1
Description: Fix PIDL compiler to do proper array allocation and length checks
 
2
Bug: https://bugzilla.samba.org/show_bug.cgi?id=8815
 
3
Origin: upstream, http://gitweb.samba.org/?p=samba.git;a=commit;h=94622cea2b2f4914b4ced35e952680c20cc4985b
 
4
Origin: upstream, http://gitweb.samba.org/?p=samba.git;a=commit;h=d15b71523d228f78f317f44181900dbf10b52e33
 
5
Origin: upstream, http://gitweb.samba.org/?p=samba.git;a=commit;h=dc9c68c8992db8225c93043757c4d33b8814c428
 
6
Origin: upstream, http://gitweb.samba.org/?p=samba.git;a=commit;h=8e99484dec90690ec1e00c17580150278963e063
 
7
Origin: upstream, http://gitweb.samba.org/?p=samba.git;a=commit;h=25f68811af3399c6148fa5d31d932465e27a2125
 
8
Origin: upstream, http://gitweb.samba.org/?p=samba.git;a=commit;h=e94415cf237d1e434daa5da70e6df0b4b6926bae
 
9
Origin: upstream, http://gitweb.samba.org/?p=samba.git;a=commit;h=3e0e6f56a671b40b21c37838ff292fe8902889bb
 
10
Origin: upstream, http://gitweb.samba.org/?p=samba.git;a=commit;h=0b9d59d256a74594e89467e5ebe4e62c25c9572e
 
11
 
 
12
Index: samba-3.6.3/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm
 
13
===================================================================
 
14
--- samba-3.6.3.orig/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm   2012-01-29 13:40:43.000000000 -0600
 
15
+++ samba-3.6.3/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm        2012-04-12 02:42:54.862479019 -0500
 
16
@@ -315,39 +315,99 @@
 
17
        }
 
18
 }
 
19
 
 
20
-#####################################################################
 
21
-# parse an array - pull side
 
22
-sub ParseArrayPullHeader($$$$$$)
 
23
+sub ParseArrayPullGetSize($$$$$$)
 
24
 {
 
25
        my ($self,$e,$l,$ndr,$var_name,$env) = @_;
 
26
 
 
27
-       my $length;
 
28
        my $size;
 
29
 
 
30
        if ($l->{IS_CONFORMANT}) {
 
31
-               $length = $size = "ndr_get_array_size($ndr, " . get_pointer_to($var_name) . ")";
 
32
+               $size = "ndr_get_array_size($ndr, " . get_pointer_to($var_name) . ")";
 
33
        } elsif ($l->{IS_ZERO_TERMINATED} and $l->{SIZE_IS} == 0 and $l->{LENGTH_IS} == 0) { # Noheader arrays
 
34
-               $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))";
 
35
+               $size = "ndr_get_string_size($ndr, sizeof(*$var_name))";
 
36
        } else {
 
37
-               $length = $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL},
 
38
+               $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL},
 
39
                        check_null_pointer($e, $env, sub { $self->pidl(shift); },
 
40
                                           "return ndr_pull_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for size_is()\");"),
 
41
                        check_fully_dereferenced($e, $env));
 
42
        }
 
43
 
 
44
+       $self->pidl("size_$e->{NAME}_$l->{LEVEL_INDEX} = $size;");
 
45
+       my $array_size = "size_$e->{NAME}_$l->{LEVEL_INDEX}";
 
46
+
 
47
+       if (my $range = has_property($e, "range")) {
 
48
+               my ($low, $high) = split(/,/, $range, 2);
 
49
+               if ($low < 0) {
 
50
+                       warning(0, "$low is invalid for the range of an array size");
 
51
+               }
 
52
+               if ($low == 0) {
 
53
+                       $self->pidl("if ($array_size > $high) {");
 
54
+               } else {
 
55
+                       $self->pidl("if ($array_size < $low || $array_size > $high) {");
 
56
+               }
 
57
+               $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");");
 
58
+               $self->pidl("}");
 
59
+       }
 
60
+
 
61
+       return $array_size;
 
62
+}
 
63
+
 
64
+#####################################################################
 
65
+# parse an array - pull side
 
66
+sub ParseArrayPullGetLength($$$$$$;$)
 
67
+{
 
68
+       my ($self,$e,$l,$ndr,$var_name,$env,$array_size) = @_;
 
69
+
 
70
+       if (not defined($array_size)) {
 
71
+               $array_size = $self->ParseArrayPullGetSize($e, $l, $ndr, $var_name, $env);
 
72
+       }
 
73
+
 
74
+       if (not $l->{IS_VARYING}) {
 
75
+               return $array_size;
 
76
+       }
 
77
+
 
78
+       my $length = "ndr_get_array_length($ndr, " . get_pointer_to($var_name) .")";
 
79
+       $self->pidl("length_$e->{NAME}_$l->{LEVEL_INDEX} = $length;");
 
80
+       my $array_length = "length_$e->{NAME}_$l->{LEVEL_INDEX}";
 
81
+
 
82
+       if (my $range = has_property($e, "range")) {
 
83
+               my ($low, $high) = split(/,/, $range, 2);
 
84
+               if ($low < 0) {
 
85
+                       warning(0, "$low is invalid for the range of an array size");
 
86
+               }
 
87
+               if ($low == 0) {
 
88
+                       $self->pidl("if ($array_length > $high) {");
 
89
+               } else {
 
90
+                       $self->pidl("if ($array_length < $low || $array_length > $high) {");
 
91
+               }
 
92
+               $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");");
 
93
+               $self->pidl("}");
 
94
+       }
 
95
+
 
96
+       return $array_length;
 
97
+}
 
98
+
 
99
+#####################################################################
 
100
+# parse an array - pull side
 
101
+sub ParseArrayPullHeader($$$$$$)
 
102
+{
 
103
+       my ($self,$e,$l,$ndr,$var_name,$env) = @_;
 
104
+
 
105
        if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) {
 
106
                $self->pidl("NDR_CHECK(ndr_pull_array_size($ndr, " . get_pointer_to($var_name) . "));");
 
107
        }
 
108
 
 
109
        if ($l->{IS_VARYING}) {
 
110
                $self->pidl("NDR_CHECK(ndr_pull_array_length($ndr, " . get_pointer_to($var_name) . "));");
 
111
-               $length = "ndr_get_array_length($ndr, " . get_pointer_to($var_name) .")";
 
112
        }
 
113
 
 
114
-       if ($length ne $size) {
 
115
-               $self->pidl("if ($length > $size) {");
 
116
+       my $array_size = $self->ParseArrayPullGetSize($e, $l, $ndr, $var_name, $env);
 
117
+       my $array_length = $self->ParseArrayPullGetLength($e, $l, $ndr, $var_name, $env, $array_size);
 
118
+
 
119
+       if ($array_length ne $array_size) {
 
120
+               $self->pidl("if ($array_length > $array_size) {");
 
121
                $self->indent;
 
122
-               $self->pidl("return ndr_pull_error($ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should exceed array length %u\", $size, $length);");
 
123
+               $self->pidl("return ndr_pull_error($ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should exceed array length %u\", $array_size, $array_length);");
 
124
                $self->deindent;
 
125
                $self->pidl("}");
 
126
        }
 
127
@@ -377,10 +437,10 @@
 
128
        }
 
129
 
 
130
        if (ArrayDynamicallyAllocated($e,$l) and not is_charset_array($e,$l)) {
 
131
-               $self->AllocateArrayLevel($e,$l,$ndr,$var_name,$size);
 
132
+               $self->AllocateArrayLevel($e,$l,$ndr,$var_name,$array_size);
 
133
        }
 
134
 
 
135
-       return $length;
 
136
+       return $array_length;
 
137
 }
 
138
 
 
139
 sub compression_alg($$)
 
140
@@ -999,6 +1059,7 @@
 
141
        my($self,$e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_;
 
142
 
 
143
        my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
 
144
+       my $array_length = undef;
 
145
 
 
146
        if ($l->{TYPE} eq "ARRAY" and ($l->{IS_VARYING} or $l->{IS_CONFORMANT})) {
 
147
                $var_name = get_pointer_to($var_name);
 
148
@@ -1012,20 +1073,7 @@
 
149
                        $self->ParseSubcontextPullEnd($e, $l, $ndr, $env);
 
150
                } elsif ($l->{TYPE} eq "ARRAY") {
 
151
                        my $length = $self->ParseArrayPullHeader($e, $l, $ndr, $var_name, $env);
 
152
-
 
153
-                       if (my $range = has_property($e, "range")) {
 
154
-                               my ($low, $high) = split(/,/, $range, 2);
 
155
-                               if ($low < 0) {
 
156
-                                       warning(0, "$low is invalid for the range of an array size");
 
157
-                               }
 
158
-                               if ($low == 0) {
 
159
-                                       $self->pidl("if ($length > $high) {");
 
160
-                               } else {
 
161
-                                       $self->pidl("if ($length < $low || $length > $high) {");
 
162
-                               }
 
163
-                               $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");");
 
164
-                               $self->pidl("}");
 
165
-                       }
 
166
+                       $array_length = $length;
 
167
 
 
168
                        my $nl = GetNextLevel($e, $l);
 
169
 
 
170
@@ -1091,26 +1139,12 @@
 
171
                }
 
172
        } elsif ($l->{TYPE} eq "ARRAY" and 
 
173
                        not has_fast_array($e,$l) and not is_charset_array($e, $l)) {
 
174
-               my $length = ParseExpr($l->{LENGTH_IS}, $env, $e->{ORIGINAL});
 
175
+               my $length = $array_length;
 
176
                my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
 
177
                my $array_name = $var_name;
 
178
 
 
179
-               if ($l->{IS_VARYING}) {
 
180
-                       $length = "ndr_get_array_length($ndr, " . get_pointer_to($var_name) .")";
 
181
-               }
 
182
-
 
183
-               if (my $range = has_property($e, "range")) {
 
184
-                       my ($low, $high) = split(/,/, $range, 2);
 
185
-                       if ($low < 0) {
 
186
-                               warning(0, "$low is invalid for the range of an array size");
 
187
-                       }
 
188
-                       if ($low == 0) {
 
189
-                               $self->pidl("if ($length > $high) {");
 
190
-                       } else {
 
191
-                               $self->pidl("if ($length < $low || $length > $high) {");
 
192
-                       }
 
193
-                       $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");");
 
194
-                       $self->pidl("}");
 
195
+               if (not defined($length)) {
 
196
+                       $length = $self->ParseArrayPullGetLength($e, $l, $ndr, $var_name, $env);
 
197
                }
 
198
 
 
199
                $var_name = get_array_element($var_name, $counter);
 
200
@@ -1527,16 +1561,21 @@
 
201
        }
 
202
 }
 
203
 
 
204
-sub DeclareArrayVariables($$)
 
205
+sub DeclareArrayVariables($$;$)
 
206
 {
 
207
-       my ($self,$e) = @_;
 
208
+       my ($self,$e,$pull) = @_;
 
209
 
 
210
        foreach my $l (@{$e->{LEVELS}}) {
 
211
+               next if ($l->{TYPE} ne "ARRAY");
 
212
+               if (defined($pull)) {
 
213
+                       $self->pidl("uint32_t size_$e->{NAME}_$l->{LEVEL_INDEX} = 0;");
 
214
+                       if ($l->{IS_VARYING}) {
 
215
+                               $self->pidl("uint32_t length_$e->{NAME}_$l->{LEVEL_INDEX} = 0;");
 
216
+                       }
 
217
+               }
 
218
                next if has_fast_array($e,$l);
 
219
                next if is_charset_array($e,$l);
 
220
-               if ($l->{TYPE} eq "ARRAY") {
 
221
-                       $self->pidl("uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};");
 
222
-               }
 
223
+               $self->pidl("uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};");
 
224
        }
 
225
 }
 
226
 
 
227
@@ -1545,15 +1584,14 @@
 
228
        my ($self,$e,$env) = @_;
 
229
 
 
230
        foreach my $l (@{$e->{LEVELS}}) {
 
231
+               next if ($l->{TYPE} ne "ARRAY");
 
232
                next if has_fast_array($e,$l);
 
233
                next if is_charset_array($e,$l);
 
234
-               if ($l->{TYPE} eq "ARRAY") {
 
235
-                   my $length = ParseExpr($l->{LENGTH_IS}, $env, $e->{ORIGINAL});
 
236
-                   if ($length eq "0") {
 
237
+               my $length = ParseExpr($l->{LENGTH_IS}, $env, $e->{ORIGINAL});
 
238
+               if ($length eq "0") {
 
239
                        warning($e->{ORIGINAL}, "pointless array cntr: 'cntr_$e->{NAME}_$l->{LEVEL_INDEX}': length=$length");
 
240
-                   } else {
 
241
+               } else {
 
242
                        $self->pidl("uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};");
 
243
-                   }
 
244
                }
 
245
        }
 
246
 }
 
247
@@ -1619,7 +1657,7 @@
 
248
        # declare any internal pointers we need
 
249
        foreach my $e (@{$struct->{ELEMENTS}}) {
 
250
                $self->DeclarePtrVariables($e);
 
251
-               $self->DeclareArrayVariables($e);
 
252
+               $self->DeclareArrayVariables($e, "pull");
 
253
                $self->DeclareMemCtxVariables($e);
 
254
        }
 
255
 
 
256
@@ -1882,8 +1920,6 @@
 
257
 
 
258
                if ($el->{TYPE} ne "EMPTY") {
 
259
                        $self->indent;
 
260
-                       $self->DeclarePtrVariables($el);
 
261
-                       $self->DeclareArrayVariables($el);
 
262
                        if (defined($e->{PROPERTIES}{relative_base})) {
 
263
                                $self->pidl("NDR_CHECK(ndr_pull_align($ndr, $el->{ALIGN}));");
 
264
                                # set the current offset as base for relative pointers
 
265
@@ -1960,6 +1996,8 @@
 
266
                next if ($el->{TYPE} eq "EMPTY");
 
267
                next if ($double_cases{"$el->{NAME}"});
 
268
                $self->DeclareMemCtxVariables($el);
 
269
+               $self->DeclarePtrVariables($el);
 
270
+               $self->DeclareArrayVariables($el, "pull");
 
271
                $double_cases{"$el->{NAME}"} = 1;
 
272
        }
 
273
 
 
274
@@ -2325,7 +2363,7 @@
 
275
        # declare any internal pointers we need
 
276
        foreach my $e (@{$fn->{ELEMENTS}}) { 
 
277
                $self->DeclarePtrVariables($e);
 
278
-               $self->DeclareArrayVariables($e);
 
279
+               $self->DeclareArrayVariables($e, "pull");
 
280
        }
 
281
 
 
282
        my %double_cases = ();