← Back to branch summary

~freerdp-team/freerdp/master

« back to all changes in this revision

Viewing changes to libfreerdp/crypto/ber.c

  • Committer: Marc-André Moreau
  • Date: 2013-05-22 12:06:52 UTC
  • mfrom: (1338.3.1 1257/head.pull)
  • Revision ID: marcandre.moreau@gmail.com-20130522120652-vti96ufewdpncatm
Merge pull request #1257 from simon-engledew/master

Ber Encoding Issue

Show diffs side-by-side

added added

removed removed

Lines of Context:
libfreerdp/crypto/ber.c
30
30
{
31
31
        BYTE byte;
32
32
 
33
 
        if(Stream_GetRemainingLength(s) < 1)
 
33
        if (Stream_GetRemainingLength(s) < 1)
34
34
                return FALSE;
35
35
        Stream_Read_UINT8(s, byte);
36
36
 
38
38
        {
39
39
                byte &= ~(0x80);
40
40
 
41
 
                if(Stream_GetRemainingLength(s) < byte)
 
41
                if (Stream_GetRemainingLength(s) < byte)
42
42
                        return FALSE;
43
43
 
44
44
                if (byte == 1)
63
63
 
64
64
int ber_write_length(wStream* s, int length)
65
65
{
66
 
        if (length > 0x7F)
 
66
        if (length > 0xFF)
67
67
        {
68
 
                Stream_Write_UINT8(s, 0x82);
 
68
                Stream_Write_UINT8(s, 0x80 ^ 2);
69
69
                Stream_Write_UINT16_BE(s, length);
70
70
                return 3;
71
71
        }
72
 
        else
 
72
        if (length > 0x7F)
73
73
        {
 
74
                Stream_Write_UINT8(s, 0x80 ^ 1);
74
75
                Stream_Write_UINT8(s, length);
75
 
                return 1;
 
76
                return 2;
76
77
        }
 
78
        Stream_Write_UINT8(s, length);
 
79
        return 1;
77
80
}
78
81
 
79
 
int _ber_skip_length(int length)
 
82
int _ber_sizeof_length(int length)
80
83
{
81
 
        if (length > 0x80)
 
84
        if (length > 0xFF)
82
85
                return 3;
83
 
        else
84
 
                return 1;
85
 
}
86
 
 
87
 
int ber_get_content_length(int length)
88
 
{
89
 
        if (length > 0x81)
90
 
                return length - 4;
91
 
        else
92
 
                return length - 2;
 
86
        if (length > 0x7F)
 
87
                return 2;
 
88
        return 1;
93
89
}
94
90
 
95
91
/**
103
99
{
104
100
        BYTE byte;
105
101
 
106
 
        if(Stream_GetRemainingLength(s) < 1)
 
102
        if (Stream_GetRemainingLength(s) < 1)
107
103
                return FALSE;
108
104
        Stream_Read_UINT8(s, byte);
109
105
 
120
116
 * @param pc primitive (FALSE) or constructed (TRUE)
121
117
 */
122
118
 
123
 
void ber_write_universal_tag(wStream* s, BYTE tag, BOOL pc)
 
119
int ber_write_universal_tag(wStream* s, BYTE tag, BOOL pc)
124
120
{
125
121
        Stream_Write_UINT8(s, (BER_CLASS_UNIV | BER_PC(pc)) | (BER_TAG_MASK & tag));
 
122
        return 1;
126
123
}
127
124
 
128
125
/**
138
135
 
139
136
        if (tag > 30)
140
137
        {
141
 
                if(Stream_GetRemainingLength(s) < 1)
 
138
                if (Stream_GetRemainingLength(s) < 1)
142
139
                        return FALSE;
143
140
                Stream_Read_UINT8(s, byte);
144
141
 
145
142
                if (byte != ((BER_CLASS_APPL | BER_CONSTRUCT) | BER_TAG_MASK))
146
143
                        return FALSE;
147
144
 
148
 
                if(Stream_GetRemainingLength(s) < 1)
 
145
                if (Stream_GetRemainingLength(s) < 1)
149
146
                        return FALSE;
150
147
                Stream_Read_UINT8(s, byte);
151
148
 
156
153
        }
157
154
        else
158
155
        {
159
 
                if(Stream_GetRemainingLength(s) < 1)
 
156
                if (Stream_GetRemainingLength(s) < 1)
160
157
                        return FALSE;
161
158
                Stream_Read_UINT8(s, byte);
162
159
 
195
192
{
196
193
        BYTE byte;
197
194
 
198
 
        if(Stream_GetRemainingLength(s) < 1)
 
195
        if (Stream_GetRemainingLength(s) < 1)
199
196
                return FALSE;
200
197
        Stream_Read_UINT8(s, byte);
201
198
 
211
208
int ber_write_contextual_tag(wStream* s, BYTE tag, int length, BOOL pc)
212
209
{
213
210
        Stream_Write_UINT8(s, (BER_CLASS_CTXT | BER_PC(pc)) | (BER_TAG_MASK & tag));
214
 
        return ber_write_length(s, length) + 1;
 
211
        return 1 + ber_write_length(s, length);
215
212
}
216
213
 
217
 
int ber_skip_contextual_tag(int length)
 
214
int ber_sizeof_contextual_tag(int length)
218
215
{
219
 
        return _ber_skip_length(length) + 1;
 
216
        return 1 + _ber_sizeof_length(length);
220
217
}
221
218
 
222
219
BOOL ber_read_sequence_tag(wStream* s, int* length)
223
220
{
224
221
        BYTE byte;
225
222
 
226
 
        if(Stream_GetRemainingLength(s) < 1)
 
223
        if (Stream_GetRemainingLength(s) < 1)
227
224
                return FALSE;
228
225
        Stream_Read_UINT8(s, byte);
229
226
 
242
239
int ber_write_sequence_tag(wStream* s, int length)
243
240
{
244
241
        Stream_Write_UINT8(s, (BER_CLASS_UNIV | BER_CONSTRUCT) | (BER_TAG_MASK & BER_TAG_SEQUENCE));
245
 
        return ber_write_length(s, length) + 1;
246
 
}
247
 
 
248
 
int ber_skip_sequence(int length)
249
 
{
250
 
        return 1 + _ber_skip_length(length) + length;
251
 
}
252
 
 
253
 
int ber_skip_sequence_tag(int length)
254
 
{
255
 
        return 1 + _ber_skip_length(length);
 
242
        return 1 + ber_write_length(s, length);
 
243
}
 
244
 
 
245
int ber_sizeof_sequence(int length)
 
246
{
 
247
        return 1 + _ber_sizeof_length(length) + length;
 
248
}
 
249
 
 
250
int ber_sizeof_sequence_tag(int length)
 
251
{
 
252
        return 1 + _ber_sizeof_length(length);
256
253
}
257
254
 
258
255
BOOL ber_read_enumerated(wStream* s, BYTE* enumerated, BYTE count)
259
256
{
260
257
        int length;
261
258
 
262
 
        if(!ber_read_universal_tag(s, BER_TAG_ENUMERATED, FALSE) ||
 
259
        if (!ber_read_universal_tag(s, BER_TAG_ENUMERATED, FALSE) ||
263
260
                !ber_read_length(s, &length))
264
261
                return FALSE;
265
262
 
284
281
 
285
282
BOOL ber_read_bit_string(wStream* s, int* length, BYTE* padding)
286
283
{
287
 
        if(!ber_read_universal_tag(s, BER_TAG_BIT_STRING, FALSE) ||
 
284
        if (!ber_read_universal_tag(s, BER_TAG_BIT_STRING, FALSE) ||
288
285
                !ber_read_length(s, length))
289
286
                return FALSE;
290
287
 
291
 
        if(Stream_GetRemainingLength(s) < 1)
 
288
        if (Stream_GetRemainingLength(s) < 1)
292
289
                return FALSE;
293
290
        Stream_Read_UINT8(s, *padding);
294
291
        return TRUE;
301
298
 * @param length string length
302
299
 */
303
300
 
304
 
void ber_write_octet_string(wStream* s, const BYTE* oct_str, int length)
 
301
int ber_write_octet_string(wStream* s, const BYTE* oct_str, int length)
305
302
{
306
 
        ber_write_universal_tag(s, BER_TAG_OCTET_STRING, FALSE);
307
 
        ber_write_length(s, length);
 
303
        int size = 0;
 
304
        size += ber_write_universal_tag(s, BER_TAG_OCTET_STRING, FALSE);
 
305
        size += ber_write_length(s, length);
308
306
        Stream_Write(s, oct_str, length);
 
307
        size += length;
 
308
        return size;
309
309
}
310
310
 
311
311
BOOL ber_read_octet_string_tag(wStream* s, int* length)
319
319
{
320
320
        ber_write_universal_tag(s, BER_TAG_OCTET_STRING, FALSE);
321
321
        ber_write_length(s, length);
322
 
        return 1 + _ber_skip_length(length);
 
322
        return 1 + _ber_sizeof_length(length);
323
323
}
324
324
 
325
 
int ber_skip_octet_string(int length)
 
325
int ber_sizeof_octet_string(int length)
326
326
{
327
 
        return 1 + _ber_skip_length(length) + length;
 
327
        return 1 + _ber_sizeof_length(length) + length;
328
328
}
329
329
 
330
330
/**
421
421
{
422
422
        ber_write_universal_tag(s, BER_TAG_INTEGER, FALSE);
423
423
 
424
 
        if (value <= 0xFF)
 
424
        if (value <  0x80)
425
425
        {
426
426
                ber_write_length(s, 1);
427
427
                Stream_Write_UINT8(s, value);
428
 
                return 2;
 
428
                return 3;
429
429
        }
430
 
        else if (value < 0xFF80)
 
430
        else if (value <  0x8000)
431
431
        {
432
432
                ber_write_length(s, 2);
433
433
                Stream_Write_UINT16_BE(s, value);
434
 
                return 3;
 
434
                return 4;
435
435
        }
436
 
        else if (value < 0xFF8000)
 
436
        else if (value <  0x800000)
437
437
        {
438
438
                ber_write_length(s, 3);
439
439
                Stream_Write_UINT8(s, (value >> 16));
440
440
                Stream_Write_UINT16_BE(s, (value & 0xFFFF));
441
 
                return 4;
 
441
                return 5;
442
442
        }
443
 
        else if (value <= 0xFFFFFFFF)
 
443
        else if (value <  0x80000000)
444
444
        {
445
445
                ber_write_length(s, 4);
446
446
                Stream_Write_UINT32_BE(s, value);
 
447
                return 6;
 
448
        }
 
449
 
 
450
        return 0;
 
451
}
 
452
 
 
453
int ber_sizeof_integer(UINT32 value)
 
454
{
 
455
        if (value < 0x80)
 
456
        {
 
457
                return 3;
 
458
        }
 
459
        else if (value < 0x8000)
 
460
        {
 
461
                return 4;
 
462
        }
 
463
        else if (value < 0x800000)
 
464
        {
447
465
                return 5;
448
466
        }
449
 
 
450
 
        return 0;
451
 
}
452
 
 
453
 
int ber_skip_integer(UINT32 value)
454
 
{
455
 
        if (value <= 0xFF)
456
 
        {
457
 
                return _ber_skip_length(1) + 2;
458
 
        }
459
 
        else if (value <= 0xFFFF)
460
 
        {
461
 
                return _ber_skip_length(2) + 3;
462
 
        }
463
 
        else if (value <= 0xFFFFFFFF)
464
 
        {
465
 
                return _ber_skip_length(4) + 5;
 
467
        else if (value < 0x80000000)
 
468
        {
 
469
                return 6;
466
470
        }
467
471
 
468
472
        return 0;