IOT-1583: Removing /W3 warning from resource/csdk/security.
[iotivity.git] / resource / csdk / security / src / base64.c
1 //******************************************************************
2 //
3 // Copyright 2015 Samsung Electronics All Rights Reserved.
4 //
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
6 //
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
10 //
11 //      http://www.apache.org/licenses/LICENSE-2.0
12 //
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
18 //
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
20
21 #include "base64.h"
22
23 /** base character of Base64. */
24 static const char g_b64TransTbl[] =
25                 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef"\
26                 "ghijklmnopqrstuvwxyz0123456789+/";
27
28 /**
29  * base64 block encode function.
30  *
31  * @param in is the octet stream, max 3 byte.
32  * @param out is the Base64 encoded stream, 4 byte.
33  * @param len is the  byte-length of octet stream.
34  *
35  * @return ::B64_OK for Success, otherwise some error value.
36  */
37 static B64Result b64EncodeBlk(const uint8_t* in, char* out, size_t len)
38 {
39     if (NULL == in || NULL ==  out || 0 == len )
40     {
41         return B64_INVALID_PARAM;
42     }
43
44     out[0] = g_b64TransTbl[in[0] >> 2];
45
46     if (1 == len)
47     {
48         out[1] = g_b64TransTbl[((in[0] & 0x03) << 4)];
49     }
50     else
51     {
52         out[1] = g_b64TransTbl[((in[0] & 0x03) << 4) | ((in[1] & 0xf0) >> 4)];
53     }
54
55     if (2 == len)
56     {
57         out[2] = g_b64TransTbl[((in[1] & 0x0f) << 2)];
58     }
59     else if (1 < len)
60     {
61         out[2] = g_b64TransTbl[((in[1] & 0x0f) << 2) | ((in[2] & 0xc0) >> 6)];
62     }
63     else
64     {
65         out[2] = '=';
66     }
67
68     if (2 < len)
69     {
70         out[3] = g_b64TransTbl[in[2] & 0x3f];
71     }
72     else
73     {
74         out[3] = '=';
75     }
76
77     return B64_OK;
78 }
79
80 B64Result b64Encode(const uint8_t* in, const size_t inLen,
81                char* outBuf, const size_t outBufSize, size_t* outLen)
82 {
83     if (NULL == in || 0 == inLen || NULL ==  outBuf || NULL == outLen )
84     {
85         return B64_INVALID_PARAM;
86     }
87
88     *outLen = ((inLen / 3) * 3 == inLen) ?
89               ((inLen / 3) * 4) :
90               (((inLen / 3) + 1) * 4);
91     size_t minBufSize = (*outLen + 1);
92     if (outBufSize < minBufSize)
93     {
94         return B64_OUTPUT_BUFFER_TOO_SMALL;
95     }
96
97     size_t i;
98     for (i = 0; i < inLen / 3; i++)
99     {
100         if(B64_OK != b64EncodeBlk(in + i * 3, outBuf + i * 4, 3))
101         {
102             return B64_INVALID_PARAM;
103         }
104     }
105
106     if ((i * 3) != inLen)
107     {
108         if (B64_OK != b64EncodeBlk(in + i * 3, outBuf + i * 4, inLen - i * 3))
109         {
110             return B64_INVALID_PARAM;
111         }
112     }
113
114     outBuf[*outLen] = '\0';
115
116     return B64_OK;
117 }
118
119 /**
120  * Get decoded value.
121  *
122  * @param c is the Base64 encoded character.
123  *
124  * @return decoded value, 6-bit.
125  */
126 static uint32_t b64GetVal(char c)
127 {
128     if (('A' <= c) && ('Z' >= c))
129     {
130         return c - 'A';
131     }
132     else if (('a' <= c) && ('z' >= c))
133     {
134         return c - 'a' + 26;
135     }
136     else if (('0' <= c) && ('9' >= c))
137     {
138         return c - '0' + 52;
139     }
140     else if ('+' == c)
141     {
142         return 62;
143     }
144     else if ('/' == c)
145     {
146         return 63;
147     }
148     else if ('=' == c)
149     {
150         return 0;
151     }
152
153     return 0;
154 }
155
156 /**
157  * Base64 block decode function.
158  *
159  * @param in is the Base64 encoded stream, 4 bytes.
160  * @param out is the Octet stream, 3 bytes.
161  *
162  * @return ::B64_OK for Success, otherwise some error value.
163  */
164 static B64Result b64DecodeBlk(const char* in, uint8_t* out)
165 {
166     if (NULL == in || NULL == out)
167     {
168         return B64_INVALID_PARAM;
169     }
170
171     uint32_t val = (b64GetVal(in[0]) << 18) | (b64GetVal(in[1]) << 12) |
172           (b64GetVal(in[2]) << 6) | (b64GetVal(in[3]));
173
174     out[0] = (val >> 16) & 0xff;
175
176     if ('=' != in[2])
177     {
178         out[1] = (val >> 8) & 0xff;
179     }
180     if ('=' != in[3])
181     {
182         out[2] = val & 0xff;
183     }
184
185     return B64_OK;
186 }
187
188 B64Result b64Decode(const char* in, const size_t inLen,
189                uint8_t* outBuf, size_t outBufSize, size_t* outLen)
190 {
191     if (NULL == in || 0 == inLen || 0 != (inLen & 0x03) || NULL == outBuf || NULL == outLen)
192     {
193         return B64_INVALID_PARAM;
194     }
195
196     *outLen = (inLen / 4) * 3;
197     size_t minBufSize = (inLen / 4) * 3;
198     if ('=' == in[inLen - 1])
199     {
200         minBufSize--;
201         (*outLen)--;
202     }
203     if ('=' == in[inLen - 2])
204     {
205         minBufSize--;
206         (*outLen)--;
207     }
208     if (outBufSize < minBufSize)
209     {
210         return B64_OUTPUT_BUFFER_TOO_SMALL;
211     }
212
213     for (size_t i = 0; i < inLen / 4; i++)
214     {
215         if(B64_OK != b64DecodeBlk(in + i * 4, outBuf + i * 3))
216         {
217             return B64_INVALID_PARAM;
218         }
219     }
220
221     return B64_OK;
222 }
223