ffead.server.doc
CryptoHandler.cpp
1 /*
2  Copyright 2009-2012, Sumeet Chhetri
3 
4  Licensed under the Apache License, Version 2.0 (the "License");
5  you may not use this file except in compliance with the License.
6  You may obtain a copy of the License at
7 
8  http://www.apache.org/licenses/LICENSE-2.0
9 
10  Unless required by applicable law or agreed to in writing, software
11  distributed under the License is distributed on an "AS IS" BASIS,
12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  See the License for the specific language governing permissions and
14  limitations under the License.
15 */
16 /*
17  * CryptoHandler.cpp
18  *
19  * Created on: Nov 24, 2010
20  * Author: sumeet
21  */
22 
23 #include "CryptoHandler.h"
24 #include "iostream"
25 CryptoHandler::CryptoHandler() {
26  // TODO Auto-generated constructor stub
27 
28 }
29 
30 CryptoHandler::~CryptoHandler() {
31  // TODO Auto-generated destructor stub
32 }
33 
34 char* CryptoHandler::base64decode(unsigned char *input, int length)
35 {
36  BIO *b64, *bmem;
37 
38  char *buffer = (char *)malloc(length);
39  memset(buffer, 0, length);
40 
41  b64 = BIO_new(BIO_f_base64());
42  BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
43  bmem = BIO_new_mem_buf(input, length);
44  bmem = BIO_push(b64, bmem);
45 
46  BIO_read(bmem, buffer, length);
47 
48  BIO_free_all(bmem);
49 
50  return buffer;
51 }
52 
53 char* CryptoHandler::base64encode(const unsigned char *input, int length)
54 {
55  BIO *bmem, *b64;
56  BUF_MEM *bptr;
57 
58  b64 = BIO_new(BIO_f_base64());
59  bmem = BIO_new(BIO_s_mem());
60  b64 = BIO_push(b64, bmem);
61  BIO_write(b64, input, length);
62  BIO_flush(b64);
63  BIO_get_mem_ptr(b64, &bptr);
64 
65  char *buff = (char *)malloc(bptr->length);
66  memcpy(buff, bptr->data, bptr->length-1);
67  buff[bptr->length-1] = 0;
68 
69  BIO_free_all(b64);
70 
71  return buff;
72 }
73 
74 char* CryptoHandler::hmac_sha1(char* datain,char* keyin,bool base64)
75 {
76  unsigned char* key = (unsigned char*) keyin;
77  unsigned char* data = (unsigned char*) datain;
78  unsigned char* result;
79  unsigned int result_len = 20;
80 
81  HMAC_CTX ctx;
82  result = (unsigned char*) malloc(sizeof(char) * result_len);
83 
84  ENGINE_load_builtin_engines();
85  ENGINE_register_all_complete();
86 
87  HMAC_CTX_init(&ctx);
88  HMAC_Init_ex(&ctx, key, strlen(keyin), EVP_sha1(), NULL);
89  HMAC_Update(&ctx, data, strlen(datain));
90  HMAC_Final(&ctx, result, &result_len);
91  HMAC_CTX_cleanup(&ctx);
92 
93  //HMAC(EVP_sha1(),key,strlen(keyin),data,strlen(datain),result,&result_len);
94  if(base64)
95  return base64encode(result,result_len);
96  return (char*)result;
97 }
98 
99 char* CryptoHandler::hmac_sha256(char* datain,char* keyin,bool base64)
100 {
101  unsigned char* key = (unsigned char*) keyin;
102  unsigned char* data = (unsigned char*) datain;
103  unsigned char* result;
104  unsigned int result_len = 32;
105 
106  HMAC_CTX ctx;
107  result = (unsigned char*) malloc(sizeof(char) * result_len);
108 
109  ENGINE_load_builtin_engines();
110  ENGINE_register_all_complete();
111 
112  HMAC_CTX_init(&ctx);
113  HMAC_Init_ex(&ctx, key, strlen(keyin), EVP_sha256(), NULL);
114  HMAC_Update(&ctx, data, strlen(datain));
115  HMAC_Final(&ctx, result, &result_len);
116  HMAC_CTX_cleanup(&ctx);
117 
118  if(base64)
119  return base64encode(result,result_len);
120  return (char*)result;
121 }
122 
123 char* CryptoHandler::hmac_sha384(char* datain,char* keyin,bool base64)
124 {
125  unsigned char* key = (unsigned char*) keyin;
126  unsigned char* data = (unsigned char*) datain;
127  unsigned char* result;
128  unsigned int result_len = 48;
129 
130  HMAC_CTX ctx;
131  result = (unsigned char*) malloc(sizeof(char) * result_len);
132 
133  ENGINE_load_builtin_engines();
134  ENGINE_register_all_complete();
135 
136  HMAC_CTX_init(&ctx);
137  HMAC_Init_ex(&ctx, key, strlen(keyin), EVP_sha384(), NULL);
138  HMAC_Update(&ctx, data, strlen(datain));
139  HMAC_Final(&ctx, result, &result_len);
140  HMAC_CTX_cleanup(&ctx);
141 
142  if(base64)
143  return base64encode(result,result_len);
144  return (char*)result;
145 }
146 
147 char* CryptoHandler::hmac_sha512(char* datain,char* keyin,bool base64)
148 {
149  unsigned char* key = (unsigned char*) keyin;
150  unsigned char* data = (unsigned char*) datain;
151  unsigned char* result;
152  unsigned int result_len = 64;
153 
154  HMAC_CTX ctx;
155  result = (unsigned char*) malloc(sizeof(char) * result_len);
156 
157  ENGINE_load_builtin_engines();
158  ENGINE_register_all_complete();
159 
160  HMAC_CTX_init(&ctx);
161  HMAC_Init_ex(&ctx, key, strlen(keyin), EVP_sha512(), NULL);
162  HMAC_Update(&ctx, data, strlen(datain));
163  HMAC_Final(&ctx, result, &result_len);
164  HMAC_CTX_cleanup(&ctx);
165 
166  if(base64)
167  return base64encode(result,result_len);
168  return (char*)result;
169 }
170 
171 
172 string CryptoHandler::urlDecode(string str)
173 {
174  string strret = str;
175  StringUtil::replaceAll(strret,"%25","%");
176  StringUtil::replaceAll(strret,"%3D","=");
177  StringUtil::replaceAll(strret,"%3A",":");
178  StringUtil::replaceAll(strret,"%20"," ");
179  StringUtil::replaceAll(strret,"%5E","^");
180  StringUtil::replaceAll(strret,"%26","&");
181  StringUtil::replaceAll(strret,"%60","`");
182  StringUtil::replaceAll(strret,"%7B","{");
183  StringUtil::replaceAll(strret,"%7D","}");
184  StringUtil::replaceAll(strret,"%7C","|");
185  StringUtil::replaceAll(strret,"%5D","]");
186  StringUtil::replaceAll(strret,"%5B","[");
187  StringUtil::replaceAll(strret,"%22","\"");
188  StringUtil::replaceAll(strret,"%3C","<");
189  StringUtil::replaceAll(strret,"%3E",">");
190  StringUtil::replaceAll(strret,"%5C","\\");
191  StringUtil::replaceAll(strret,"%23","#");
192  StringUtil::replaceAll(strret,"%3F","?");
193  StringUtil::replaceAll(strret,"%2F","/");
194  StringUtil::replaceAll(strret,"%2B","+");
195  return strret;
196 }
197 
198 string CryptoHandler::urlEncode(string str)
199 {
200  string strret;
201  int len = str.length();
202  for(int i=0; i<len; i++)
203  {
204  switch(str[i])
205  {
206  case '%':
207  strret.append("%25");
208  break;
209  case '=':
210  strret.append("%3D");
211  break;
212  case ':':
213  strret.append("%3A");
214  break;
215  case ' ':
216  strret.append("%20");
217  break;
218  case '^':
219  strret.append("%5E");
220  break;
221  case '&':
222  strret.append("%26");
223  break;
224  case '`':
225  strret.append("%60");
226  break;
227  case '{':
228  strret.append("%7B");
229  break;
230  case '}':
231  strret.append("%7D");
232  break;
233  case '|':
234  strret.append("%7C");
235  break;
236  case ']':
237  strret.append("%5D");
238  break;
239  case '[':
240  strret.append("%5B");
241  break;
242  case '"':
243  strret.append("%22");
244  break;
245  case '<':
246  strret.append("%3C");
247  break;
248  case '>':
249  strret.append("%3E");
250  break;
251  case '\\':
252  strret.append("%5C");
253  break;
254  case '#':
255  strret.append("%23");
256  break;
257  case '?':
258  strret.append("%3F");
259  break;
260  case '/':
261  strret.append("%2F");
262  break;
263  case '+':
264  strret.append("%2B");
265  break;
266  default:
267  strret.push_back(str[i]);
268  break;
269  }
270  }
271  return strret;
272 }