encode.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452
  1. /* crypto/evp/encode.c */
  2. /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  3. * All rights reserved.
  4. *
  5. * This package is an SSL implementation written
  6. * by Eric Young (eay@cryptsoft.com).
  7. * The implementation was written so as to conform with Netscapes SSL.
  8. *
  9. * This library is free for commercial and non-commercial use as long as
  10. * the following conditions are aheared to. The following conditions
  11. * apply to all code found in this distribution, be it the RC4, RSA,
  12. * lhash, DES, etc., code; not just the SSL code. The SSL documentation
  13. * included with this distribution is covered by the same copyright terms
  14. * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15. *
  16. * Copyright remains Eric Young's, and as such any Copyright notices in
  17. * the code are not to be removed.
  18. * If this package is used in a product, Eric Young should be given attribution
  19. * as the author of the parts of the library used.
  20. * This can be in the form of a textual message at program startup or
  21. * in documentation (online or textual) provided with the package.
  22. *
  23. * Redistribution and use in source and binary forms, with or without
  24. * modification, are permitted provided that the following conditions
  25. * are met:
  26. * 1. Redistributions of source code must retain the copyright
  27. * notice, this list of conditions and the following disclaimer.
  28. * 2. Redistributions in binary form must reproduce the above copyright
  29. * notice, this list of conditions and the following disclaimer in the
  30. * documentation and/or other materials provided with the distribution.
  31. * 3. All advertising materials mentioning features or use of this software
  32. * must display the following acknowledgement:
  33. * "This product includes cryptographic software written by
  34. * Eric Young (eay@cryptsoft.com)"
  35. * The word 'cryptographic' can be left out if the rouines from the library
  36. * being used are not cryptographic related :-).
  37. * 4. If you include any Windows specific code (or a derivative thereof) from
  38. * the apps directory (application code) you must include an acknowledgement:
  39. * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40. *
  41. * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44. * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51. * SUCH DAMAGE.
  52. *
  53. * The licence and distribution terms for any publically available version or
  54. * derivative of this code cannot be changed. i.e. this code cannot simply be
  55. * copied and put under another distribution licence
  56. * [including the GNU Public Licence.]
  57. */
  58. #include <stdio.h>
  59. #include "cryptlib.h"
  60. #include <openssl/evp.h>
  61. #ifndef CHARSET_EBCDIC
  62. # define conv_bin2ascii(a) (data_bin2ascii[(a)&0x3f])
  63. # define conv_ascii2bin(a) (data_ascii2bin[(a)&0x7f])
  64. #else
  65. /*
  66. * We assume that PEM encoded files are EBCDIC files (i.e., printable text
  67. * files). Convert them here while decoding. When encoding, output is EBCDIC
  68. * (text) format again. (No need for conversion in the conv_bin2ascii macro,
  69. * as the underlying textstring data_bin2ascii[] is already EBCDIC)
  70. */
  71. # define conv_bin2ascii(a) (data_bin2ascii[(a)&0x3f])
  72. # define conv_ascii2bin(a) (data_ascii2bin[os_toascii[a]&0x7f])
  73. #endif
  74. /*-
  75. * 64 char lines
  76. * pad input with 0
  77. * left over chars are set to =
  78. * 1 byte => xx==
  79. * 2 bytes => xxx=
  80. * 3 bytes => xxxx
  81. */
  82. #define BIN_PER_LINE (64/4*3)
  83. #define CHUNKS_PER_LINE (64/4)
  84. #define CHAR_PER_LINE (64+1)
  85. static unsigned char data_bin2ascii[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ\
  86. abcdefghijklmnopqrstuvwxyz0123456789+/";
  87. /*-
  88. * 0xF0 is a EOLN
  89. * 0xF1 is ignore but next needs to be 0xF0 (for \r\n processing).
  90. * 0xF2 is EOF
  91. * 0xE0 is ignore at start of line.
  92. * 0xFF is error
  93. */
  94. #define B64_EOLN 0xF0
  95. #define B64_CR 0xF1
  96. #define B64_EOF 0xF2
  97. #define B64_WS 0xE0
  98. #define B64_ERROR 0xFF
  99. #define B64_NOT_BASE64(a) (((a)|0x13) == 0xF3)
  100. static unsigned char data_ascii2bin[128] = {
  101. 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  102. 0xFF, 0xE0, 0xF0, 0xFF, 0xFF, 0xF1, 0xFF, 0xFF,
  103. 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  104. 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  105. 0xE0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  106. 0xFF, 0xFF, 0xFF, 0x3E, 0xFF, 0xF2, 0xFF, 0x3F,
  107. 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
  108. 0x3C, 0x3D, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF,
  109. 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
  110. 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
  111. 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
  112. 0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  113. 0xFF, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
  114. 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
  115. 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
  116. 0x31, 0x32, 0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  117. };
  118. void EVP_EncodeInit(EVP_ENCODE_CTX *ctx)
  119. {
  120. ctx->length = 48;
  121. ctx->num = 0;
  122. ctx->line_num = 0;
  123. }
  124. void EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
  125. const unsigned char *in, int inl)
  126. {
  127. int i, j;
  128. unsigned int total = 0;
  129. *outl = 0;
  130. if (inl == 0)
  131. return;
  132. OPENSSL_assert(ctx->length <= (int)sizeof(ctx->enc_data));
  133. if ((ctx->num + inl) < ctx->length) {
  134. memcpy(&(ctx->enc_data[ctx->num]), in, inl);
  135. ctx->num += inl;
  136. return;
  137. }
  138. if (ctx->num != 0) {
  139. i = ctx->length - ctx->num;
  140. memcpy(&(ctx->enc_data[ctx->num]), in, i);
  141. in += i;
  142. inl -= i;
  143. j = EVP_EncodeBlock(out, ctx->enc_data, ctx->length);
  144. ctx->num = 0;
  145. out += j;
  146. *(out++) = '\n';
  147. *out = '\0';
  148. total = j + 1;
  149. }
  150. while (inl >= ctx->length) {
  151. j = EVP_EncodeBlock(out, in, ctx->length);
  152. in += ctx->length;
  153. inl -= ctx->length;
  154. out += j;
  155. *(out++) = '\n';
  156. *out = '\0';
  157. total += j + 1;
  158. }
  159. if (inl != 0)
  160. memcpy(&(ctx->enc_data[0]), in, inl);
  161. ctx->num = inl;
  162. *outl = total;
  163. }
  164. void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl)
  165. {
  166. unsigned int ret = 0;
  167. if (ctx->num != 0) {
  168. ret = EVP_EncodeBlock(out, ctx->enc_data, ctx->num);
  169. out[ret++] = '\n';
  170. out[ret] = '\0';
  171. ctx->num = 0;
  172. }
  173. *outl = ret;
  174. }
  175. int EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int dlen)
  176. {
  177. int i, ret = 0;
  178. unsigned long l;
  179. for (i = dlen; i > 0; i -= 3) {
  180. if (i >= 3) {
  181. l = (((unsigned long)f[0]) << 16L) |
  182. (((unsigned long)f[1]) << 8L) | f[2];
  183. *(t++) = conv_bin2ascii(l >> 18L);
  184. *(t++) = conv_bin2ascii(l >> 12L);
  185. *(t++) = conv_bin2ascii(l >> 6L);
  186. *(t++) = conv_bin2ascii(l);
  187. } else {
  188. l = ((unsigned long)f[0]) << 16L;
  189. if (i == 2)
  190. l |= ((unsigned long)f[1] << 8L);
  191. *(t++) = conv_bin2ascii(l >> 18L);
  192. *(t++) = conv_bin2ascii(l >> 12L);
  193. *(t++) = (i == 1) ? '=' : conv_bin2ascii(l >> 6L);
  194. *(t++) = '=';
  195. }
  196. ret += 4;
  197. f += 3;
  198. }
  199. *t = '\0';
  200. return (ret);
  201. }
  202. void EVP_DecodeInit(EVP_ENCODE_CTX *ctx)
  203. {
  204. ctx->length = 30;
  205. ctx->num = 0;
  206. ctx->line_num = 0;
  207. ctx->expect_nl = 0;
  208. }
  209. /*-
  210. * -1 for error
  211. * 0 for last line
  212. * 1 for full line
  213. */
  214. int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
  215. const unsigned char *in, int inl)
  216. {
  217. int seof = -1, eof = 0, rv = -1, ret = 0, i, v, tmp, n, ln, exp_nl;
  218. unsigned char *d;
  219. n = ctx->num;
  220. d = ctx->enc_data;
  221. ln = ctx->line_num;
  222. exp_nl = ctx->expect_nl;
  223. /* last line of input. */
  224. if ((inl == 0) || ((n == 0) && (conv_ascii2bin(in[0]) == B64_EOF))) {
  225. rv = 0;
  226. goto end;
  227. }
  228. /* We parse the input data */
  229. for (i = 0; i < inl; i++) {
  230. /* If the current line is > 80 characters, scream alot */
  231. if (ln >= 80) {
  232. rv = -1;
  233. goto end;
  234. }
  235. /* Get char and put it into the buffer */
  236. tmp = *(in++);
  237. v = conv_ascii2bin(tmp);
  238. /* only save the good data :-) */
  239. if (!B64_NOT_BASE64(v)) {
  240. OPENSSL_assert(n < (int)sizeof(ctx->enc_data));
  241. d[n++] = tmp;
  242. ln++;
  243. } else if (v == B64_ERROR) {
  244. rv = -1;
  245. goto end;
  246. }
  247. /*
  248. * have we seen a '=' which is 'definitly' the last input line. seof
  249. * will point to the character that holds it. and eof will hold how
  250. * many characters to chop off.
  251. */
  252. if (tmp == '=') {
  253. if (seof == -1)
  254. seof = n;
  255. eof++;
  256. }
  257. if (v == B64_CR) {
  258. ln = 0;
  259. if (exp_nl)
  260. continue;
  261. }
  262. /* eoln */
  263. if (v == B64_EOLN) {
  264. ln = 0;
  265. if (exp_nl) {
  266. exp_nl = 0;
  267. continue;
  268. }
  269. }
  270. exp_nl = 0;
  271. /*
  272. * If we are at the end of input and it looks like a line, process
  273. * it.
  274. */
  275. if (((i + 1) == inl) && (((n & 3) == 0) || eof)) {
  276. v = B64_EOF;
  277. /*
  278. * In case things were given us in really small records (so two
  279. * '=' were given in separate updates), eof may contain the
  280. * incorrect number of ending bytes to skip, so let's redo the
  281. * count
  282. */
  283. eof = 0;
  284. if (d[n - 1] == '=')
  285. eof++;
  286. if (d[n - 2] == '=')
  287. eof++;
  288. /* There will never be more than two '=' */
  289. }
  290. if ((v == B64_EOF && (n & 3) == 0) || (n >= 64)) {
  291. /*
  292. * This is needed to work correctly on 64 byte input lines. We
  293. * process the line and then need to accept the '\n'
  294. */
  295. if ((v != B64_EOF) && (n >= 64))
  296. exp_nl = 1;
  297. if (n > 0) {
  298. v = EVP_DecodeBlock(out, d, n);
  299. n = 0;
  300. if (v < 0) {
  301. rv = 0;
  302. goto end;
  303. }
  304. if (eof > v) {
  305. rv = -1;
  306. goto end;
  307. }
  308. ret += (v - eof);
  309. } else {
  310. eof = 1;
  311. v = 0;
  312. }
  313. /*
  314. * This is the case where we have had a short but valid input
  315. * line
  316. */
  317. if ((v < ctx->length) && eof) {
  318. rv = 0;
  319. goto end;
  320. } else
  321. ctx->length = v;
  322. if (seof >= 0) {
  323. rv = 0;
  324. goto end;
  325. }
  326. out += v;
  327. }
  328. }
  329. rv = 1;
  330. end:
  331. *outl = ret;
  332. ctx->num = n;
  333. ctx->line_num = ln;
  334. ctx->expect_nl = exp_nl;
  335. return (rv);
  336. }
  337. int EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n)
  338. {
  339. int i, ret = 0, a, b, c, d;
  340. unsigned long l;
  341. /* trim white space from the start of the line. */
  342. while ((conv_ascii2bin(*f) == B64_WS) && (n > 0)) {
  343. f++;
  344. n--;
  345. }
  346. /*
  347. * strip off stuff at the end of the line ascii2bin values B64_WS,
  348. * B64_EOLN, B64_EOLN and B64_EOF
  349. */
  350. while ((n > 3) && (B64_NOT_BASE64(conv_ascii2bin(f[n - 1]))))
  351. n--;
  352. if (n % 4 != 0)
  353. return (-1);
  354. for (i = 0; i < n; i += 4) {
  355. a = conv_ascii2bin(*(f++));
  356. b = conv_ascii2bin(*(f++));
  357. c = conv_ascii2bin(*(f++));
  358. d = conv_ascii2bin(*(f++));
  359. if ((a & 0x80) || (b & 0x80) || (c & 0x80) || (d & 0x80))
  360. return (-1);
  361. l = ((((unsigned long)a) << 18L) |
  362. (((unsigned long)b) << 12L) |
  363. (((unsigned long)c) << 6L) | (((unsigned long)d)));
  364. *(t++) = (unsigned char)(l >> 16L) & 0xff;
  365. *(t++) = (unsigned char)(l >> 8L) & 0xff;
  366. *(t++) = (unsigned char)(l) & 0xff;
  367. ret += 3;
  368. }
  369. return (ret);
  370. }
  371. int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl)
  372. {
  373. int i;
  374. *outl = 0;
  375. if (ctx->num != 0) {
  376. i = EVP_DecodeBlock(out, ctx->enc_data, ctx->num);
  377. if (i < 0)
  378. return (-1);
  379. ctx->num = 0;
  380. *outl = i;
  381. return (1);
  382. } else
  383. return (1);
  384. }
  385. #ifdef undef
  386. int EVP_DecodeValid(unsigned char *buf, int len)
  387. {
  388. int i, num = 0, bad = 0;
  389. if (len == 0)
  390. return (-1);
  391. while (conv_ascii2bin(*buf) == B64_WS) {
  392. buf++;
  393. len--;
  394. if (len == 0)
  395. return (-1);
  396. }
  397. for (i = len; i >= 4; i -= 4) {
  398. if ((conv_ascii2bin(buf[0]) >= 0x40) ||
  399. (conv_ascii2bin(buf[1]) >= 0x40) ||
  400. (conv_ascii2bin(buf[2]) >= 0x40) ||
  401. (conv_ascii2bin(buf[3]) >= 0x40))
  402. return (-1);
  403. buf += 4;
  404. num += 1 + (buf[2] != '=') + (buf[3] != '=');
  405. }
  406. if ((i == 1) && (conv_ascii2bin(buf[0]) == B64_EOLN))
  407. return (num);
  408. if ((i == 2) && (conv_ascii2bin(buf[0]) == B64_EOLN) &&
  409. (conv_ascii2bin(buf[0]) == B64_EOLN))
  410. return (num);
  411. return (1);
  412. }
  413. #endif