← 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: Brian Aker
  • Date: 2010-10-20 20:26:18 UTC
  • mfrom: (1859.2.13 refactor)
  • Revision ID: brian@tangent.org-20101020202618-9222n39lm329urv5
Merge for Brian 

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbms/src/cslib/CSEncode.cc
1
 
/* Copyright (C) 2008 PrimeBase Technologies GmbH, Germany
 
1
/* Copyright (c) 2008 PrimeBase Technologies GmbH, Germany
2
2
 *
3
3
 * PrimeBase S3Daemon
4
4
 *
28
28
 
29
29
#include "CSEncode.h"
30
30
 
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] = {
 
31
static const u_char base64Map[64] = {
42
32
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 
43
33
        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 
44
34
        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 
50
40
};
51
41
 
52
42
static const u_char decodeBase64Map[128] = {
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, 
 
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, 
59
49
        0X34, 0X35, 0X36, 0X37, 0X38, 0X39, 0X3A, 0X3B, 
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, 
 
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, 
66
56
        0X21, 0X22, 0X23, 0X24, 0X25, 0X26, 0X27, 0X28, 
67
57
        0X29, 0X2A, 0X2B, 0X2C, 0X2D, 0X2E, 0X2F, 0X30, 
68
 
        0X31, 0X32, 0X33, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
 
58
        0X31, 0X32, 0X33, 0X0, 0X90, 0X1B, 0XBA, 0X48, 
69
59
};
70
60
 
71
 
//------------------
72
 
static bool base64Encoded(const u_char *data, size_t len, const u_char *vc)
 
61
 
 
62
static bool base64Encoded(const u_char *data, size_t len)
73
63
{
74
64
        if (len % 4)
75
65
                return false;
82
72
                return false;
83
73
                
84
74
        for (; i ; i--, data++) {
85
 
                if (((*data < 'A') || (*data > 'Z')) &&
86
 
                        ((*data < 'a') || (*data > 'z')) &&
87
 
                        ((*data < '0') || (*data > '9')) &&
88
 
                        ((*data != vc[0]) && (*data != vc[1])))
 
75
                if (*data > 63)
89
76
                        return false;
90
77
        }
91
78
        
92
79
        return true; // Actually this isn't so much 'true' as 'maybe'
93
80
}
94
81
 
95
 
//------------------
96
 
static char *genericBase64Encode(const void *data, size_t len, char *encode_buffer, size_t encode_buffer_len, const u_char base64Map[])
 
82
char *base64Encode(const void *data, size_t len)
97
83
{
98
84
        u_char *wptr, *rptr, *encoding;
99
85
        size_t size;
100
86
        enter_();
101
87
 
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--;
 
88
        size = ((len + 2) / 3) * 4;
 
89
        encoding = (u_char *) cs_malloc(size +1);
112
90
        encoding[size] = 0;
113
91
        
114
92
        wptr= encoding;
141
119
        return_((char*)encoding);
142
120
}
143
121
 
144
 
//------------------
145
 
static void *genericBase64Decode(const char *data, size_t len, void *decode_buffer, size_t decode_buffer_len, const u_char base64Map[])
 
122
void *base64Decode(const char *data, size_t len)
146
123
{
 
124
        uint32_t tail;
147
125
        u_char *wptr, *rptr, *decoding;
148
126
        enter_();
149
127
 
150
128
        rptr = (u_char *) data;
151
129
 
152
 
        if (!base64Encoded(rptr, len, base64Map +62)) 
 
130
        if (!base64Encoded(rptr, len)) 
153
131
                CSException::throwException(CS_CONTEXT, CS_ERR_GENERIC_ERROR, "String was not Base64 encoded.");
154
132
        
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
161
133
        decoding = (u_char *) cs_malloc((len/ 4) * 3);
162
134
        
163
135
        wptr= decoding;
164
136
        
165
 
        while (rptr[len-1] == '=') 
166
 
                len--; 
 
137
        tail = len; 
 
138
        while (rptr[tail-1] == '=') 
 
139
                tail--; 
167
140
 
 
141
        len -= tail;
168
142
        while (len/4) {         
169
143
                wptr[0] = ( ((decodeBase64Map[rptr[0]] << 2) & 0xFF) | ((decodeBase64Map[rptr[1]] >> 4) & 0x03) ); 
170
144
                wptr[1] = ( ((decodeBase64Map[rptr[1]] << 4) & 0xFF) | ((decodeBase64Map[rptr[2]] >> 2) & 0x0F) ); 
184
158
        return_(decoding);
185
159
}
186
160
 
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
 
 
211
161
#ifdef NOT_USED
212
162
//-----------------------------------------------------
213
163
void  hmac_md5(u_char *text, size_t text_len, u_char *key, size_t key_len, Md5Digest *digest)