← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/pbms/src/cslib/CSEncode.cc

  • Committer: Barry.Leslie at PrimeBase
  • Date: 2010-10-18 21:21:20 UTC
  • mto: This revision was merged to the branch mainline in revision 1871.
  • Revision ID: barry.leslie@primebase.com-20101018212120-dqukgtkwhb1imt1o
Merged changes from lp:pbms. These changes should remove any danger
of longjmp() clobbering local variables.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbms/src/cslib/CSEncode.cc
28
28
 
29
29
#include "CSEncode.h"
30
30
 
31
 
static const u_char base64Map[64] = {
 
31
static const u_char base64URLMap[64] = {
 
32
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 
 
33
        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 
 
34
        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 
 
35
        'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 
 
36
        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 
 
37
        'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 
 
38
        'w', 'x', 'y', 'z', '0', '1', '2', '3', 
 
39
        '4', '5', '6', '7', '8', '9', '-', '_'
 
40
};
 
41
static const u_char base64STDMap[64] = {
32
42
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 
33
43
        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 
34
44
        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 
40
50
};
41
51
 
42
52
static const u_char decodeBase64Map[128] = {
43
 
        0XBF, 0XFF, 0XF2, 0X2C, 0XBF, 0XFF, 0XF2, 0X24, 
44
 
        0X0, 0X0, 0X2E, 0X4C, 0X0, 0X0, 0X0, 0X3, 
45
 
        0X0, 0X0, 0X0, 0X3, 0XBF, 0XFF, 0XF1, 0X40, 
46
 
        0X0, 0X0, 0X0, 0X50, 0X8F, 0XE1, 0X56, 0XD8, 
47
 
        0X0, 0X30, 0X6, 0XEC, 0X0, 0X30, 0X6, 0XF0, 
48
 
        0X0, 0X0, 0X2E, 0X3E, 0X0, 0X0, 0X0, 0X3F, 
 
53
        0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
 
54
        0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
 
55
        0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
 
56
        0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
 
57
        0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
 
58
        0XFF, 0XFF, 0XFF, 0X3E, 0XFF, 0X3E, 0XFF, 0X3F, 
49
59
        0X34, 0X35, 0X36, 0X37, 0X38, 0X39, 0X3A, 0X3B, 
50
 
        0X3C, 0X3D, 0X2C, 0X68, 0X90, 0X0, 0X17, 0XD8, 
51
 
        0XBF, 0X0, 0X1, 0X2, 0X3, 0X4, 0X5, 0X6, 
52
 
        0X7, 0X8, 0X9, 0XA, 0XB, 0XC, 0XD, 0XE, 
53
 
        0XF, 0X10, 0X11, 0X12, 0X13, 0X14, 0X15, 0X16, 
54
 
        0X17, 0X18, 0X19, 0X80, 0X0, 0X0, 0X0, 0X0, 
55
 
        0X0, 0X1A, 0X1B, 0X1C, 0X1D, 0X1E, 0X1F, 0X20, 
 
60
        0X3C, 0X3D, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
 
61
        0XFF, 0X00, 0X01, 0X02, 0X03, 0X04, 0X05, 0X06, 
 
62
        0X07, 0X08, 0X09, 0X0A, 0X0B, 0X0C, 0X0D, 0X0E, 
 
63
        0X0F, 0X10, 0X11, 0X12, 0X13, 0X14, 0X15, 0X16, 
 
64
        0X17, 0X18, 0X19, 0XFF, 0XFF, 0XFF, 0XFF, 0X3F, 
 
65
        0XFF, 0X1A, 0X1B, 0X1C, 0X1D, 0X1E, 0X1F, 0X20, 
56
66
        0X21, 0X22, 0X23, 0X24, 0X25, 0X26, 0X27, 0X28, 
57
67
        0X29, 0X2A, 0X2B, 0X2C, 0X2D, 0X2E, 0X2F, 0X30, 
58
 
        0X31, 0X32, 0X33, 0X0, 0X90, 0X1B, 0XBA, 0X48, 
 
68
        0X31, 0X32, 0X33, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
59
69
};
60
70
 
61
 
 
62
 
static bool base64Encoded(const u_char *data, size_t len)
 
71
//------------------
 
72
static bool base64Encoded(const u_char *data, size_t len, const u_char *vc)
63
73
{
64
74
        if (len % 4)
65
75
                return false;
72
82
                return false;
73
83
                
74
84
        for (; i ; i--, data++) {
75
 
                if (*data > 63)
 
85
                if (((*data < 'A') || (*data > 'Z')) &&
 
86
                        ((*data < 'a') || (*data > 'z')) &&
 
87
                        ((*data < '0') || (*data > '9')) &&
 
88
                        ((*data != vc[0]) && (*data != vc[1])))
76
89
                        return false;
77
90
        }
78
91
        
79
92
        return true; // Actually this isn't so much 'true' as 'maybe'
80
93
}
81
94
 
82
 
char *base64Encode(const void *data, size_t len)
 
95
//------------------
 
96
static char *genericBase64Encode(const void *data, size_t len, char *encode_buffer, size_t encode_buffer_len, const u_char base64Map[])
83
97
{
84
98
        u_char *wptr, *rptr, *encoding;
85
99
        size_t size;
86
100
        enter_();
87
101
 
88
 
        size = ((len + 2) / 3) * 4;
89
 
        encoding = (u_char *) cs_malloc(size +1);
 
102
        size = ((len + 2) / 3) * 4 +1;
 
103
        if ((encode_buffer != NULL) && (encode_buffer_len < size)) 
 
104
                CSException::throwException(CS_CONTEXT, CS_ERR_GENERIC_ERROR, "Base64 encode buffer is too small.");
 
105
        
 
106
        if (encode_buffer)
 
107
                encoding = (u_char *) encode_buffer;
 
108
        else
 
109
                encoding = (u_char *) cs_malloc(size);
 
110
                
 
111
        size--;
90
112
        encoding[size] = 0;
91
113
        
92
114
        wptr= encoding;
119
141
        return_((char*)encoding);
120
142
}
121
143
 
122
 
void *base64Decode(const char *data, size_t len)
 
144
//------------------
 
145
static void *genericBase64Decode(const char *data, size_t len, void *decode_buffer, size_t decode_buffer_len, const u_char base64Map[])
123
146
{
124
 
        uint32_t tail;
125
147
        u_char *wptr, *rptr, *decoding;
126
148
        enter_();
127
149
 
128
150
        rptr = (u_char *) data;
129
151
 
130
 
        if (!base64Encoded(rptr, len)) 
 
152
        if (!base64Encoded(rptr, len, base64Map +62)) 
131
153
                CSException::throwException(CS_CONTEXT, CS_ERR_GENERIC_ERROR, "String was not Base64 encoded.");
132
154
        
 
155
        if ((decode_buffer != NULL) && (decode_buffer_len < ((len/ 4) * 3))) 
 
156
                CSException::throwException(CS_CONTEXT, CS_ERR_GENERIC_ERROR, "Base64 decoded buffer is too small.");
 
157
        
 
158
        if (decode_buffer)
 
159
                decoding = (u_char *) decode_buffer;
 
160
        else
133
161
        decoding = (u_char *) cs_malloc((len/ 4) * 3);
134
162
        
135
163
        wptr= decoding;
136
164
        
137
 
        tail = len; 
138
 
        while (rptr[tail-1] == '=') 
139
 
                tail--; 
 
165
        while (rptr[len-1] == '=') 
 
166
                len--; 
140
167
 
141
 
        len -= tail;
142
168
        while (len/4) {         
143
169
                wptr[0] = ( ((decodeBase64Map[rptr[0]] << 2) & 0xFF) | ((decodeBase64Map[rptr[1]] >> 4) & 0x03) ); 
144
170
                wptr[1] = ( ((decodeBase64Map[rptr[1]] << 4) & 0xFF) | ((decodeBase64Map[rptr[2]] >> 2) & 0x0F) ); 
158
184
        return_(decoding);
159
185
}
160
186
 
 
187
//------------------
 
188
char *base64Encode(const void *data, size_t len, char *encode_buffer, size_t encode_buffer_len)
 
189
{
 
190
        return genericBase64Encode(data, len, encode_buffer, encode_buffer_len, base64STDMap);
 
191
}
 
192
 
 
193
//------------------
 
194
void *base64Decode(const char *data, size_t len, void *decode_buffer, size_t decode_buffer_len)
 
195
{
 
196
        return genericBase64Decode(data, len, decode_buffer, decode_buffer_len, base64STDMap);
 
197
}
 
198
 
 
199
//------------------
 
200
char *base64UrlEncode(const void *data, size_t len, char *encode_buffer, size_t encode_buffer_len)
 
201
{
 
202
        return genericBase64Encode(data, len, encode_buffer, encode_buffer_len, base64URLMap);
 
203
}
 
204
 
 
205
//------------------
 
206
void *base64UrlDecode(const char *data, size_t len, void *decode_buffer, size_t decode_buffer_len)
 
207
{
 
208
        return genericBase64Decode(data, len, decode_buffer, decode_buffer_len, base64URLMap);
 
209
}
 
210
 
161
211
#ifdef NOT_USED
162
212
//-----------------------------------------------------
163
213
void  hmac_md5(u_char *text, size_t text_len, u_char *key, size_t key_len, Md5Digest *digest)