SIP channel name uniqueness
[asterisk/asterisk.git] / funcs / func_aes.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2009, Digium, Inc.
5  *
6  * See http://www.asterisk.org for more information about
7  * the Asterisk project. Please do not directly contact
8  * any of the maintainers of this project for assistance;
9  * the project provides a web site, mailing lists and IRC
10  * channels for your use.
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License Version 2. See the LICENSE file
14  * at the top of the source tree.
15  */
16
17 /*! \file
18  *
19  * \brief AES encryption/decryption dialplan functions
20  *
21  * \author David Vossel <dvossel@digium.com>
22  * \ingroup functions
23  */
24
25
26 #include "asterisk.h"
27
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include "asterisk/module.h"
31 #include "asterisk/pbx.h"
32 #include "asterisk/app.h"
33 #include "asterisk/aes.h"
34 #include "asterisk/strings.h"
35
36 #define AES_BLOCK_SIZE 16
37
38 /*** DOCUMENTATION
39         <function name="AES_ENCRYPT" language="en_US">
40                 <synopsis>
41                         Encrypt a string with AES given a 16 character key.
42                 </synopsis>
43                 <syntax>
44                         <parameter name="key" required="true">
45                                 <para>AES Key</para>
46                         </parameter>
47                         <parameter name="string" required="true">
48                                 <para>Input string</para>
49                         </parameter>
50                 </syntax>
51                 <description>
52                         <para>Returns an AES encrypted string encoded in base64.</para>
53                 </description>
54         </function>
55         <function name="AES_DECRYPT" language="en_US">
56                 <synopsis>
57                         Decrypt a string encoded in base64 with AES given a 16 character key.
58                 </synopsis>
59                 <syntax>
60                         <parameter name="key" required="true">
61                                 <para>AES Key</para>
62                         </parameter>
63                         <parameter name="string" required="true">
64                                 <para>Input string.</para>
65                         </parameter>
66                 </syntax>
67                 <description>
68                         <para>Returns the plain text string.</para>
69                 </description>
70         </function>
71  ***/
72
73
74 static int aes_helper(struct ast_channel *chan, const char *cmd, char *data,
75                char *buf, struct ast_str **str, ssize_t maxlen)
76 {
77         unsigned char curblock[AES_BLOCK_SIZE] = { 0, };
78         char *tmp = NULL;
79         char *tmpP;
80         int data_len, encrypt;
81         int keylen, len, tmplen, elen = 0;
82         ast_aes_encrypt_key ecx;                        /*  AES 128 Encryption context */
83         ast_aes_decrypt_key dcx;
84         AST_DECLARE_APP_ARGS(args,
85                 AST_APP_ARG(key);
86                 AST_APP_ARG(data);
87         );
88
89         AST_STANDARD_APP_ARGS(args, data);
90
91         if (ast_strlen_zero(args.data) || ast_strlen_zero(args.key)) {
92                 ast_log(LOG_WARNING, "Syntax: %s(<key>,<data>) - missing argument!\n", cmd);
93                 return -1;
94         }
95
96         if ((keylen = strlen(args.key)) != AES_BLOCK_SIZE) {        /* key must be of 16 characters in length, 128 bits */
97                 ast_log(LOG_WARNING, "Syntax: %s(<key>,<data>) - <key> parameter must be exactly 16 characters%s!\n", cmd, keylen < 16 ? " - padding" : "");
98                 return -1;
99         }
100
101         if (buf) {
102                 len = maxlen;
103         } else if (maxlen == -1) {
104                 len = ast_str_size(*str);
105         } else if (maxlen > 0) {
106                 len = maxlen;
107         } else {
108                 len = INT_MAX;
109         }
110         ast_debug(3, "len=%d\n", len);
111
112         encrypt = strcmp("AES_DECRYPT", cmd);           /* -1 if encrypting, 0 if decrypting */
113         /* Round up the buffer to an even multiple of 16, plus 1 */
114         tmplen = (strlen(args.data) / 16 + 1) * 16 + 1;
115         tmp = ast_calloc(1, tmplen);
116         tmpP = tmp;
117
118         if (encrypt) {                                  /* if decrypting first decode src to base64 */
119                 /* encryption:  plaintext -> encryptedtext -> base64 */
120                 ast_aes_encrypt_key((unsigned char *) args.key, &ecx);
121                 strcpy(tmp, args.data);
122                 data_len = strlen(tmp);
123         } else {
124                 /* decryption:  base64 -> encryptedtext -> plaintext */
125                 ast_aes_decrypt_key((unsigned char *) args.key, &dcx);
126                 data_len = ast_base64decode((unsigned char *) tmp, args.data, tmplen);
127         }
128
129         if (data_len >= len) {                        /* make sure to not go over buffer len */
130                 ast_log(LOG_WARNING, "Syntax: %s(<keys>,<data>) - <data> exceeds buffer length.  Result may be truncated!\n", cmd);
131                 data_len = len - 1;
132         }
133
134         while (data_len > 0) {
135                 /* Tricky operation.  We first copy the data into curblock, then
136                  * the data is encrypted or decrypted and put back into the original
137                  * buffer. */
138                 memset(curblock, 0, AES_BLOCK_SIZE);
139                 memcpy(curblock, tmpP, AES_BLOCK_SIZE);
140                 if (encrypt) {
141                         ast_aes_encrypt(curblock, (unsigned char *) tmpP, &ecx);
142                 } else {
143                         ast_aes_decrypt(curblock, (unsigned char *) tmpP, &dcx);
144                 }
145                 tmpP += AES_BLOCK_SIZE;
146                 data_len -= AES_BLOCK_SIZE;
147                 elen += AES_BLOCK_SIZE;
148         }
149
150         if (encrypt) {                            /* if encrypting encode result to base64 */
151                 if (buf) {
152                         ast_base64encode(buf, (unsigned char *) tmp, elen, len);
153                 } else {
154                         if (maxlen >= 0) {
155                                 ast_str_make_space(str, maxlen ? maxlen : elen * 4 / 3 + 2);
156                         }
157                         ast_base64encode(ast_str_buffer(*str), (unsigned char *) tmp, elen, ast_str_size(*str));
158                         ast_str_update(*str);
159                 }
160         } else {
161                 if (buf) {
162                         memcpy(buf, tmp, len);
163                 } else {
164                         ast_str_set(str, maxlen, "%s", tmp);
165                 }
166         }
167         ast_free(tmp);
168
169         return 0;
170 }
171
172 static int aes_buf_helper(struct ast_channel *chan, const char *cmd, char *data,
173                char *buf, size_t maxlen)
174 {
175         return aes_helper(chan, cmd, data, buf, NULL, maxlen);
176 }
177
178 static int aes_str_helper(struct ast_channel *chan, const char *cmd, char *data,
179                struct ast_str **buf, ssize_t maxlen)
180 {
181         return aes_helper(chan, cmd, data, NULL, buf, maxlen);
182 }
183
184 static struct ast_custom_function aes_encrypt_function = {
185         .name = "AES_ENCRYPT",
186         .read = aes_buf_helper,
187         .read2 = aes_str_helper,
188 };
189
190 static struct ast_custom_function aes_decrypt_function = {
191         .name = "AES_DECRYPT",
192         .read = aes_buf_helper,
193         .read2 = aes_str_helper,
194 };
195
196 static int unload_module(void)
197 {
198         int res = ast_custom_function_unregister(&aes_decrypt_function);
199         return res | ast_custom_function_unregister(&aes_encrypt_function);
200 }
201
202 static int load_module(void)
203 {
204         int res = ast_custom_function_register(&aes_decrypt_function);
205         res |= ast_custom_function_register(&aes_encrypt_function);
206         return res ? AST_MODULE_LOAD_DECLINE : AST_MODULE_LOAD_SUCCESS;
207 }
208
209 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "AES dialplan functions");