← Back to branch summary

~ubuntu-branches/ubuntu/precise/tiff/precise-security

« back to all changes in this revision

Viewing changes to .pc/CVE-2014-81xx-7.patch/tools/pal2rgb.c

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2015-03-30 08:11:18 UTC
  • Revision ID: package-import@ubuntu.com-20150330081118-bvaoaii1act27voq
Tags: 3.9.5-2ubuntu1.7
* SECURITY UPDATE: Fix multiple security issues
  - debian/patches/CVE-2014-81xx-1.patch to CVE-2014-81xx-11.patch
  - debian/patches/CVE-2014-8128-5.patch
  - debian/patches/CVE-2014-9655-1.patch to CVE-2014-9655-3.patch
  - debian/patches/read_overrun.patch
  - debian/patches/CVE-2014-8130.patch
  - CVE-2014-8127 (partially)
  - CVE-2014-8128
  - CVE-2014-8129
  - CVE-2014-8130
  - CVE-2014-9330
  - CVE-2014-9655

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/CVE-2014-81xx-7.patch/tools/pal2rgb.c
 
1
/* $Id: pal2rgb.c,v 1.10.2.2 2010-07-02 12:03:27 dron Exp $ */
 
2
 
 
3
/*
 
4
 * Copyright (c) 1988-1997 Sam Leffler
 
5
 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
 
6
 *
 
7
 * Permission to use, copy, modify, distribute, and sell this software and 
 
8
 * its documentation for any purpose is hereby granted without fee, provided
 
9
 * that (i) the above copyright notices and this permission notice appear in
 
10
 * all copies of the software and related documentation, and (ii) the names of
 
11
 * Sam Leffler and Silicon Graphics may not be used in any advertising or
 
12
 * publicity relating to the software without the specific, prior written
 
13
 * permission of Sam Leffler and Silicon Graphics.
 
14
 * 
 
15
 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
 
16
 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
 
17
 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
 
18
 * 
 
19
 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
 
20
 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
 
21
 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 
22
 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
 
23
 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
 
24
 * OF THIS SOFTWARE.
 
25
 */
 
26
 
 
27
#include "tif_config.h"
 
28
 
 
29
#include <stdio.h>
 
30
#include <string.h>
 
31
#include <stdlib.h>
 
32
#include <ctype.h>
 
33
 
 
34
#ifdef HAVE_UNISTD_H
 
35
# include <unistd.h>
 
36
#endif
 
37
 
 
38
#include "tiffio.h"
 
39
 
 
40
#define streq(a,b)      (strcmp(a,b) == 0)
 
41
#define strneq(a,b,n)   (strncmp(a,b,n) == 0)
 
42
 
 
43
static  void usage(void);
 
44
static  void cpTags(TIFF* in, TIFF* out);
 
45
 
 
46
static int
 
47
checkcmap(int n, uint16* r, uint16* g, uint16* b)
 
48
{
 
49
        while (n-- > 0)
 
50
            if (*r++ >= 256 || *g++ >= 256 || *b++ >= 256)
 
51
                return (16);
 
52
        fprintf(stderr, "Warning, assuming 8-bit colormap.\n");
 
53
        return (8);
 
54
}
 
55
 
 
56
#define CopyField(tag, v) \
 
57
    if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
 
58
#define CopyField3(tag, v1, v2, v3) \
 
59
    if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
 
60
 
 
61
static  uint16 compression = (uint16) -1;
 
62
static  uint16 predictor = 0;
 
63
static  int quality = 75;       /* JPEG quality */
 
64
static  int jpegcolormode = JPEGCOLORMODE_RGB;
 
65
static  int processCompressOptions(char*);
 
66
 
 
67
int
 
68
main(int argc, char* argv[])
 
69
{
 
70
        uint16 bitspersample, shortv;
 
71
        uint32 imagewidth, imagelength;
 
72
        uint16 config = PLANARCONFIG_CONTIG;
 
73
        uint32 rowsperstrip = (uint32) -1;
 
74
        uint16 photometric = PHOTOMETRIC_RGB;
 
75
        uint16 *rmap, *gmap, *bmap;
 
76
        uint32 row;
 
77
        int cmap = -1;
 
78
        TIFF *in, *out;
 
79
        int c;
 
80
        extern int optind;
 
81
        extern char* optarg;
 
82
 
 
83
        while ((c = getopt(argc, argv, "C:c:p:r:")) != -1)
 
84
                switch (c) {
 
85
                case 'C':               /* force colormap interpretation */
 
86
                        cmap = atoi(optarg);
 
87
                        break;
 
88
                case 'c':               /* compression scheme */
 
89
                        if (!processCompressOptions(optarg))
 
90
                                usage();
 
91
                        break;
 
92
                case 'p':               /* planar configuration */
 
93
                        if (streq(optarg, "separate"))
 
94
                                config = PLANARCONFIG_SEPARATE;
 
95
                        else if (streq(optarg, "contig"))
 
96
                                config = PLANARCONFIG_CONTIG;
 
97
                        else
 
98
                                usage();
 
99
                        break;
 
100
                case 'r':               /* rows/strip */
 
101
                        rowsperstrip = atoi(optarg);
 
102
                        break;
 
103
                case '?':
 
104
                        usage();
 
105
                        /*NOTREACHED*/
 
106
                }
 
107
        if (argc - optind != 2)
 
108
                usage();
 
109
        in = TIFFOpen(argv[optind], "r");
 
110
        if (in == NULL)
 
111
                return (-1);
 
112
        if (!TIFFGetField(in, TIFFTAG_PHOTOMETRIC, &shortv) ||
 
113
            shortv != PHOTOMETRIC_PALETTE) {
 
114
                fprintf(stderr, "%s: Expecting a palette image.\n",
 
115
                    argv[optind]);
 
116
                return (-1);
 
117
        }
 
118
        if (!TIFFGetField(in, TIFFTAG_COLORMAP, &rmap, &gmap, &bmap)) {
 
119
                fprintf(stderr,
 
120
                    "%s: No colormap (not a valid palette image).\n",
 
121
                    argv[optind]);
 
122
                return (-1);
 
123
        }
 
124
        bitspersample = 0;
 
125
        TIFFGetField(in, TIFFTAG_BITSPERSAMPLE, &bitspersample);
 
126
        if (bitspersample != 8) {
 
127
                fprintf(stderr, "%s: Sorry, can only handle 8-bit images.\n",
 
128
                    argv[optind]);
 
129
                return (-1);
 
130
        }
 
131
        out = TIFFOpen(argv[optind+1], "w");
 
132
        if (out == NULL)
 
133
                return (-2);
 
134
        cpTags(in, out);
 
135
        TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &imagewidth);
 
136
        TIFFGetField(in, TIFFTAG_IMAGELENGTH, &imagelength);
 
137
        if (compression != (uint16)-1)
 
138
                TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
 
139
        else
 
140
                TIFFGetField(in, TIFFTAG_COMPRESSION, &compression);
 
141
        switch (compression) {
 
142
        case COMPRESSION_JPEG:
 
143
                if (jpegcolormode == JPEGCOLORMODE_RGB)
 
144
                        photometric = PHOTOMETRIC_YCBCR;
 
145
                else
 
146
                        photometric = PHOTOMETRIC_RGB;
 
147
                TIFFSetField(out, TIFFTAG_JPEGQUALITY, quality);
 
148
                TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, jpegcolormode);
 
149
                break;
 
150
        case COMPRESSION_LZW:
 
151
        case COMPRESSION_DEFLATE:
 
152
                if (predictor != 0)
 
153
                        TIFFSetField(out, TIFFTAG_PREDICTOR, predictor);
 
154
                break;
 
155
        }
 
156
        TIFFSetField(out, TIFFTAG_PHOTOMETRIC, photometric);
 
157
        TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 3);
 
158
        TIFFSetField(out, TIFFTAG_PLANARCONFIG, config);
 
159
        TIFFSetField(out, TIFFTAG_ROWSPERSTRIP,
 
160
            rowsperstrip = TIFFDefaultStripSize(out, rowsperstrip));
 
161
        (void) TIFFGetField(in, TIFFTAG_PLANARCONFIG, &shortv);
 
162
        if (cmap == -1)
 
163
                cmap = checkcmap(1<<bitspersample, rmap, gmap, bmap);
 
164
        if (cmap == 16) {
 
165
                /*
 
166
                 * Convert 16-bit colormap to 8-bit.
 
167
                 */
 
168
                int i;
 
169
 
 
170
                for (i = (1<<bitspersample)-1; i >= 0; i--) {
 
171
#define CVT(x)          (((x) * 255) / ((1L<<16)-1))
 
172
                        rmap[i] = CVT(rmap[i]);
 
173
                        gmap[i] = CVT(gmap[i]);
 
174
                        bmap[i] = CVT(bmap[i]);
 
175
                }
 
176
        }
 
177
        { unsigned char *ibuf, *obuf;
 
178
          register unsigned char* pp;
 
179
          register uint32 x;
 
180
          ibuf = (unsigned char*)_TIFFmalloc(TIFFScanlineSize(in));
 
181
          obuf = (unsigned char*)_TIFFmalloc(TIFFScanlineSize(out));
 
182
          switch (config) {
 
183
          case PLANARCONFIG_CONTIG:
 
184
                for (row = 0; row < imagelength; row++) {
 
185
                        if (!TIFFReadScanline(in, ibuf, row, 0))
 
186
                                goto done;
 
187
                        pp = obuf;
 
188
                        for (x = 0; x < imagewidth; x++) {
 
189
                                *pp++ = (unsigned char) rmap[ibuf[x]];
 
190
                                *pp++ = (unsigned char) gmap[ibuf[x]];
 
191
                                *pp++ = (unsigned char) bmap[ibuf[x]];
 
192
                        }
 
193
                        if (!TIFFWriteScanline(out, obuf, row, 0))
 
194
                                goto done;
 
195
                }
 
196
                break;
 
197
          case PLANARCONFIG_SEPARATE:
 
198
                for (row = 0; row < imagelength; row++) {
 
199
                        if (!TIFFReadScanline(in, ibuf, row, 0))
 
200
                                goto done;
 
201
                        for (pp = obuf, x = 0; x < imagewidth; x++)
 
202
                                *pp++ = (unsigned char) rmap[ibuf[x]];
 
203
                        if (!TIFFWriteScanline(out, obuf, row, 0))
 
204
                                goto done;
 
205
                        for (pp = obuf, x = 0; x < imagewidth; x++)
 
206
                                *pp++ = (unsigned char) gmap[ibuf[x]];
 
207
                        if (!TIFFWriteScanline(out, obuf, row, 0))
 
208
                                goto done;
 
209
                        for (pp = obuf, x = 0; x < imagewidth; x++)
 
210
                                *pp++ = (unsigned char) bmap[ibuf[x]];
 
211
                        if (!TIFFWriteScanline(out, obuf, row, 0))
 
212
                                goto done;
 
213
                }
 
214
                break;
 
215
          }
 
216
          _TIFFfree(ibuf);
 
217
          _TIFFfree(obuf);
 
218
        }
 
219
done:
 
220
        (void) TIFFClose(in);
 
221
        (void) TIFFClose(out);
 
222
        return (0);
 
223
}
 
224
 
 
225
static int
 
226
processCompressOptions(char* opt)
 
227
{
 
228
        if (streq(opt, "none"))
 
229
                compression = COMPRESSION_NONE;
 
230
        else if (streq(opt, "packbits"))
 
231
                compression = COMPRESSION_PACKBITS;
 
232
        else if (strneq(opt, "jpeg", 4)) {
 
233
                char* cp = strchr(opt, ':');
 
234
 
 
235
                compression = COMPRESSION_JPEG;
 
236
                while( cp )
 
237
                {
 
238
                    if (isdigit((int)cp[1]))
 
239
                        quality = atoi(cp+1);
 
240
                    else if (cp[1] == 'r' )
 
241
                        jpegcolormode = JPEGCOLORMODE_RAW;
 
242
                    else
 
243
                        usage();
 
244
 
 
245
                    cp = strchr(cp+1,':');
 
246
                }
 
247
        } else if (strneq(opt, "lzw", 3)) {
 
248
                char* cp = strchr(opt, ':');
 
249
                if (cp)
 
250
                        predictor = atoi(cp+1);
 
251
                compression = COMPRESSION_LZW;
 
252
        } else if (strneq(opt, "zip", 3)) {
 
253
                char* cp = strchr(opt, ':');
 
254
                if (cp)
 
255
                        predictor = atoi(cp+1);
 
256
                compression = COMPRESSION_DEFLATE;
 
257
        } else
 
258
                return (0);
 
259
        return (1);
 
260
}
 
261
 
 
262
#define CopyField(tag, v) \
 
263
    if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
 
264
#define CopyField2(tag, v1, v2) \
 
265
    if (TIFFGetField(in, tag, &v1, &v2)) TIFFSetField(out, tag, v1, v2)
 
266
#define CopyField3(tag, v1, v2, v3) \
 
267
    if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
 
268
#define CopyField4(tag, v1, v2, v3, v4) \
 
269
    if (TIFFGetField(in, tag, &v1, &v2, &v3, &v4)) TIFFSetField(out, tag, v1, v2, v3, v4)
 
270
 
 
271
static void
 
272
cpTag(TIFF* in, TIFF* out, uint16 tag, uint16 count, TIFFDataType type)
 
273
{
 
274
        switch (type) {
 
275
        case TIFF_SHORT:
 
276
                if (count == 1) {
 
277
                        uint16 shortv;
 
278
                        CopyField(tag, shortv);
 
279
                } else if (count == 2) {
 
280
                        uint16 shortv1, shortv2;
 
281
                        CopyField2(tag, shortv1, shortv2);
 
282
                } else if (count == 4) {
 
283
                        uint16 *tr, *tg, *tb, *ta;
 
284
                        CopyField4(tag, tr, tg, tb, ta);
 
285
                } else if (count == (uint16) -1) {
 
286
                        uint16 shortv1;
 
287
                        uint16* shortav;
 
288
                        CopyField2(tag, shortv1, shortav);
 
289
                }
 
290
                break;
 
291
        case TIFF_LONG:
 
292
                { uint32 longv;
 
293
                  CopyField(tag, longv);
 
294
                }
 
295
                break;
 
296
        case TIFF_RATIONAL:
 
297
                if (count == 1) {
 
298
                        float floatv;
 
299
                        CopyField(tag, floatv);
 
300
                } else if (count == (uint16) -1) {
 
301
                        float* floatav;
 
302
                        CopyField(tag, floatav);
 
303
                }
 
304
                break;
 
305
        case TIFF_ASCII:
 
306
                { char* stringv;
 
307
                  CopyField(tag, stringv);
 
308
                }
 
309
                break;
 
310
        case TIFF_DOUBLE:
 
311
                if (count == 1) {
 
312
                        double doublev;
 
313
                        CopyField(tag, doublev);
 
314
                } else if (count == (uint16) -1) {
 
315
                        double* doubleav;
 
316
                        CopyField(tag, doubleav);
 
317
                }
 
318
                break;
 
319
          default:
 
320
                TIFFError(TIFFFileName(in),
 
321
                          "Data type %d is not supported, tag %d skipped.",
 
322
                          tag, type);
 
323
        }
 
324
}
 
325
 
 
326
#undef CopyField4
 
327
#undef CopyField3
 
328
#undef CopyField2
 
329
#undef CopyField
 
330
 
 
331
static struct cpTag {
 
332
    uint16      tag;
 
333
    uint16      count;
 
334
    TIFFDataType type;
 
335
} tags[] = {
 
336
    { TIFFTAG_IMAGEWIDTH,               1, TIFF_LONG },
 
337
    { TIFFTAG_IMAGELENGTH,              1, TIFF_LONG },
 
338
    { TIFFTAG_BITSPERSAMPLE,            1, TIFF_SHORT },
 
339
    { TIFFTAG_COMPRESSION,              1, TIFF_SHORT },
 
340
    { TIFFTAG_FILLORDER,                1, TIFF_SHORT },
 
341
    { TIFFTAG_ROWSPERSTRIP,             1, TIFF_LONG },
 
342
    { TIFFTAG_GROUP3OPTIONS,            1, TIFF_LONG },
 
343
    { TIFFTAG_SUBFILETYPE,              1, TIFF_LONG },
 
344
    { TIFFTAG_THRESHHOLDING,            1, TIFF_SHORT },
 
345
    { TIFFTAG_DOCUMENTNAME,             1, TIFF_ASCII },
 
346
    { TIFFTAG_IMAGEDESCRIPTION,         1, TIFF_ASCII },
 
347
    { TIFFTAG_MAKE,                     1, TIFF_ASCII },
 
348
    { TIFFTAG_MODEL,                    1, TIFF_ASCII },
 
349
    { TIFFTAG_ORIENTATION,              1, TIFF_SHORT },
 
350
    { TIFFTAG_MINSAMPLEVALUE,           1, TIFF_SHORT },
 
351
    { TIFFTAG_MAXSAMPLEVALUE,           1, TIFF_SHORT },
 
352
    { TIFFTAG_XRESOLUTION,              1, TIFF_RATIONAL },
 
353
    { TIFFTAG_YRESOLUTION,              1, TIFF_RATIONAL },
 
354
    { TIFFTAG_PAGENAME,                 1, TIFF_ASCII },
 
355
    { TIFFTAG_XPOSITION,                1, TIFF_RATIONAL },
 
356
    { TIFFTAG_YPOSITION,                1, TIFF_RATIONAL },
 
357
    { TIFFTAG_GROUP4OPTIONS,            1, TIFF_LONG },
 
358
    { TIFFTAG_RESOLUTIONUNIT,           1, TIFF_SHORT },
 
359
    { TIFFTAG_PAGENUMBER,               2, TIFF_SHORT },
 
360
    { TIFFTAG_SOFTWARE,                 1, TIFF_ASCII },
 
361
    { TIFFTAG_DATETIME,                 1, TIFF_ASCII },
 
362
    { TIFFTAG_ARTIST,                   1, TIFF_ASCII },
 
363
    { TIFFTAG_HOSTCOMPUTER,             1, TIFF_ASCII },
 
364
    { TIFFTAG_WHITEPOINT,               2, TIFF_RATIONAL },
 
365
    { TIFFTAG_PRIMARYCHROMATICITIES,    (uint16) -1,TIFF_RATIONAL },
 
366
    { TIFFTAG_HALFTONEHINTS,            2, TIFF_SHORT },
 
367
    { TIFFTAG_BADFAXLINES,              1, TIFF_LONG },
 
368
    { TIFFTAG_CLEANFAXDATA,             1, TIFF_SHORT },
 
369
    { TIFFTAG_CONSECUTIVEBADFAXLINES,   1, TIFF_LONG },
 
370
    { TIFFTAG_INKSET,                   1, TIFF_SHORT },
 
371
    { TIFFTAG_INKNAMES,                 1, TIFF_ASCII },
 
372
    { TIFFTAG_DOTRANGE,                 2, TIFF_SHORT },
 
373
    { TIFFTAG_TARGETPRINTER,            1, TIFF_ASCII },
 
374
    { TIFFTAG_SAMPLEFORMAT,             1, TIFF_SHORT },
 
375
    { TIFFTAG_YCBCRCOEFFICIENTS,        (uint16) -1,TIFF_RATIONAL },
 
376
    { TIFFTAG_YCBCRSUBSAMPLING,         2, TIFF_SHORT },
 
377
    { TIFFTAG_YCBCRPOSITIONING,         1, TIFF_SHORT },
 
378
    { TIFFTAG_REFERENCEBLACKWHITE,      (uint16) -1,TIFF_RATIONAL },
 
379
};
 
380
#define NTAGS   (sizeof (tags) / sizeof (tags[0]))
 
381
 
 
382
static void
 
383
cpTags(TIFF* in, TIFF* out)
 
384
{
 
385
    struct cpTag *p;
 
386
    for (p = tags; p < &tags[NTAGS]; p++)
 
387
        cpTag(in, out, p->tag, p->count, p->type);
 
388
}
 
389
#undef NTAGS
 
390
 
 
391
char* stuff[] = {
 
392
"usage: pal2rgb [options] input.tif output.tif",
 
393
"where options are:",
 
394
" -p contig     pack samples contiguously (e.g. RGBRGB...)",
 
395
" -p separate   store samples separately (e.g. RRR...GGG...BBB...)",
 
396
" -r #          make each strip have no more than # rows",
 
397
" -C 8          assume 8-bit colormap values (instead of 16-bit)",
 
398
" -C 16         assume 16-bit colormap values",
 
399
"",
 
400
" -c lzw[:opts] compress output with Lempel-Ziv & Welch encoding",
 
401
" -c zip[:opts] compress output with deflate encoding",
 
402
" -c packbits   compress output with packbits encoding",
 
403
" -c none       use no compression algorithm on output",
 
404
"",
 
405
"LZW and deflate options:",
 
406
" #             set predictor value",
 
407
"For example, -c lzw:2 to get LZW-encoded data with horizontal differencing",
 
408
NULL
 
409
};
 
410
 
 
411
static void
 
412
usage(void)
 
413
{
 
414
        char buf[BUFSIZ];
 
415
        int i;
 
416
 
 
417
        setbuf(stderr, buf);
 
418
        fprintf(stderr, "%s\n\n", TIFFGetVersion());
 
419
        for (i = 0; stuff[i] != NULL; i++)
 
420
                fprintf(stderr, "%s\n", stuff[i]);
 
421
        exit(-1);
 
422
}
 
423
 
 
424
/* vim: set ts=8 sts=8 sw=8 noet: */
 
425
/*
 
426
 * Local Variables:
 
427
 * mode: c
 
428
 * c-basic-offset: 8
 
429
 * fill-column: 78
 
430
 * End:
 
431
 */