Commit 05da18964b890daccac951b07bedb844044a0fa4

Authored by Georg Hopp
0 parents

initial checkin

  1 +.*.swp
  1 +/* -*- buffer-read-only: t -*- vi: set ro: */
  2 +/* DO NOT EDIT! GENERATED AUTOMATICALLY! */
  3 +/* base64.c -- Encode binary data using printable characters.
  4 + Copyright (C) 1999, 2000, 2001, 2004, 2005, 2006, 2009, 2010 Free Software
  5 + Foundation, Inc.
  6 +
  7 + This program is free software; you can redistribute it and/or modify
  8 + it under the terms of the GNU General Public License as published by
  9 + the Free Software Foundation; either version 3, or (at your option)
  10 + any later version.
  11 +
  12 + This program is distributed in the hope that it will be useful,
  13 + but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 + GNU General Public License for more details.
  16 +
  17 + You should have received a copy of the GNU General Public License
  18 + along with this program; if not, write to the Free Software Foundation,
  19 + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
  20 +
  21 +/* Written by Simon Josefsson. Partially adapted from GNU MailUtils
  22 + * (mailbox/filter_trans.c, as of 2004-11-28). Improved by review
  23 + * from Paul Eggert, Bruno Haible, and Stepan Kasal.
  24 + *
  25 + * See also RFC 3548 <http://www.ietf.org/rfc/rfc3548.txt>.
  26 + *
  27 + * Be careful with error checking. Here is how you would typically
  28 + * use these functions:
  29 + *
  30 + * bool ok = base64_decode_alloc (in, inlen, &out, &outlen);
  31 + * if (!ok)
  32 + * FAIL: input was not valid base64
  33 + * if (out == NULL)
  34 + * FAIL: memory allocation error
  35 + * OK: data in OUT/OUTLEN
  36 + *
  37 + * size_t outlen = base64_encode_alloc (in, inlen, &out);
  38 + * if (out == NULL && outlen == 0 && inlen != 0)
  39 + * FAIL: input too long
  40 + * if (out == NULL)
  41 + * FAIL: memory allocation error
  42 + * OK: data in OUT/OUTLEN.
  43 + *
  44 + */
  45 +
  46 +/* Get prototype. */
  47 +#include "base64.h"
  48 +
  49 +/* Get malloc. */
  50 +#include <stdlib.h>
  51 +
  52 +/* Get UCHAR_MAX. */
  53 +#include <limits.h>
  54 +
  55 +#include <string.h>
  56 +
  57 +/* C89 compliant way to cast 'char' to 'unsigned char'. */
  58 +static inline unsigned char
  59 +to_uchar (char ch)
  60 +{
  61 + return ch;
  62 +}
  63 +
  64 +/* Base64 encode IN array of size INLEN into OUT array of size OUTLEN.
  65 + If OUTLEN is less than BASE64_LENGTH(INLEN), write as many bytes as
  66 + possible. If OUTLEN is larger than BASE64_LENGTH(INLEN), also zero
  67 + terminate the output buffer. */
  68 +void
  69 +base64_encode (const char *restrict in, size_t inlen,
  70 + char *restrict out, size_t outlen)
  71 +{
  72 + static const char b64str[64] =
  73 + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  74 +
  75 + while (inlen && outlen)
  76 + {
  77 + *out++ = b64str[(to_uchar (in[0]) >> 2) & 0x3f];
  78 + if (!--outlen)
  79 + break;
  80 + *out++ = b64str[((to_uchar (in[0]) << 4)
  81 + + (--inlen ? to_uchar (in[1]) >> 4 : 0))
  82 + & 0x3f];
  83 + if (!--outlen)
  84 + break;
  85 + *out++ =
  86 + (inlen
  87 + ? b64str[((to_uchar (in[1]) << 2)
  88 + + (--inlen ? to_uchar (in[2]) >> 6 : 0))
  89 + & 0x3f]
  90 + : '=');
  91 + if (!--outlen)
  92 + break;
  93 + *out++ = inlen ? b64str[to_uchar (in[2]) & 0x3f] : '=';
  94 + if (!--outlen)
  95 + break;
  96 + if (inlen)
  97 + inlen--;
  98 + if (inlen)
  99 + in += 3;
  100 + }
  101 +
  102 + if (outlen)
  103 + *out = '\0';
  104 +}
  105 +
  106 +/* Allocate a buffer and store zero terminated base64 encoded data
  107 + from array IN of size INLEN, returning BASE64_LENGTH(INLEN), i.e.,
  108 + the length of the encoded data, excluding the terminating zero. On
  109 + return, the OUT variable will hold a pointer to newly allocated
  110 + memory that must be deallocated by the caller. If output string
  111 + length would overflow, 0 is returned and OUT is set to NULL. If
  112 + memory allocation failed, OUT is set to NULL, and the return value
  113 + indicates length of the requested memory block, i.e.,
  114 + BASE64_LENGTH(inlen) + 1. */
  115 +size_t
  116 +base64_encode_alloc (const char *in, size_t inlen, char **out)
  117 +{
  118 + size_t outlen = 1 + BASE64_LENGTH (inlen);
  119 +
  120 + /* Check for overflow in outlen computation.
  121 + *
  122 + * If there is no overflow, outlen >= inlen.
  123 + *
  124 + * If the operation (inlen + 2) overflows then it yields at most +1, so
  125 + * outlen is 0.
  126 + *
  127 + * If the multiplication overflows, we lose at least half of the
  128 + * correct value, so the result is < ((inlen + 2) / 3) * 2, which is
  129 + * less than (inlen + 2) * 0.66667, which is less than inlen as soon as
  130 + * (inlen > 4).
  131 + */
  132 + if (inlen > outlen)
  133 + {
  134 + *out = NULL;
  135 + return 0;
  136 + }
  137 +
  138 + *out = malloc (outlen);
  139 + if (!*out)
  140 + return outlen;
  141 +
  142 + base64_encode (in, inlen, *out, outlen);
  143 +
  144 + return outlen - 1;
  145 +}
  146 +
  147 +/* With this approach this file works independent of the charset used
  148 + (think EBCDIC). However, it does assume that the characters in the
  149 + Base64 alphabet (A-Za-z0-9+/) are encoded in 0..255. POSIX
  150 + 1003.1-2001 require that char and unsigned char are 8-bit
  151 + quantities, though, taking care of that problem. But this may be a
  152 + potential problem on non-POSIX C99 platforms.
  153 +
  154 + IBM C V6 for AIX mishandles "#define B64(x) ...'x'...", so use "_"
  155 + as the formal parameter rather than "x". */
  156 +#define B64(_) \
  157 + ((_) == 'A' ? 0 \
  158 + : (_) == 'B' ? 1 \
  159 + : (_) == 'C' ? 2 \
  160 + : (_) == 'D' ? 3 \
  161 + : (_) == 'E' ? 4 \
  162 + : (_) == 'F' ? 5 \
  163 + : (_) == 'G' ? 6 \
  164 + : (_) == 'H' ? 7 \
  165 + : (_) == 'I' ? 8 \
  166 + : (_) == 'J' ? 9 \
  167 + : (_) == 'K' ? 10 \
  168 + : (_) == 'L' ? 11 \
  169 + : (_) == 'M' ? 12 \
  170 + : (_) == 'N' ? 13 \
  171 + : (_) == 'O' ? 14 \
  172 + : (_) == 'P' ? 15 \
  173 + : (_) == 'Q' ? 16 \
  174 + : (_) == 'R' ? 17 \
  175 + : (_) == 'S' ? 18 \
  176 + : (_) == 'T' ? 19 \
  177 + : (_) == 'U' ? 20 \
  178 + : (_) == 'V' ? 21 \
  179 + : (_) == 'W' ? 22 \
  180 + : (_) == 'X' ? 23 \
  181 + : (_) == 'Y' ? 24 \
  182 + : (_) == 'Z' ? 25 \
  183 + : (_) == 'a' ? 26 \
  184 + : (_) == 'b' ? 27 \
  185 + : (_) == 'c' ? 28 \
  186 + : (_) == 'd' ? 29 \
  187 + : (_) == 'e' ? 30 \
  188 + : (_) == 'f' ? 31 \
  189 + : (_) == 'g' ? 32 \
  190 + : (_) == 'h' ? 33 \
  191 + : (_) == 'i' ? 34 \
  192 + : (_) == 'j' ? 35 \
  193 + : (_) == 'k' ? 36 \
  194 + : (_) == 'l' ? 37 \
  195 + : (_) == 'm' ? 38 \
  196 + : (_) == 'n' ? 39 \
  197 + : (_) == 'o' ? 40 \
  198 + : (_) == 'p' ? 41 \
  199 + : (_) == 'q' ? 42 \
  200 + : (_) == 'r' ? 43 \
  201 + : (_) == 's' ? 44 \
  202 + : (_) == 't' ? 45 \
  203 + : (_) == 'u' ? 46 \
  204 + : (_) == 'v' ? 47 \
  205 + : (_) == 'w' ? 48 \
  206 + : (_) == 'x' ? 49 \
  207 + : (_) == 'y' ? 50 \
  208 + : (_) == 'z' ? 51 \
  209 + : (_) == '0' ? 52 \
  210 + : (_) == '1' ? 53 \
  211 + : (_) == '2' ? 54 \
  212 + : (_) == '3' ? 55 \
  213 + : (_) == '4' ? 56 \
  214 + : (_) == '5' ? 57 \
  215 + : (_) == '6' ? 58 \
  216 + : (_) == '7' ? 59 \
  217 + : (_) == '8' ? 60 \
  218 + : (_) == '9' ? 61 \
  219 + : (_) == '+' ? 62 \
  220 + : (_) == '/' ? 63 \
  221 + : -1)
  222 +
  223 +static const signed char b64[0x100] = {
  224 + B64 (0), B64 (1), B64 (2), B64 (3),
  225 + B64 (4), B64 (5), B64 (6), B64 (7),
  226 + B64 (8), B64 (9), B64 (10), B64 (11),
  227 + B64 (12), B64 (13), B64 (14), B64 (15),
  228 + B64 (16), B64 (17), B64 (18), B64 (19),
  229 + B64 (20), B64 (21), B64 (22), B64 (23),
  230 + B64 (24), B64 (25), B64 (26), B64 (27),
  231 + B64 (28), B64 (29), B64 (30), B64 (31),
  232 + B64 (32), B64 (33), B64 (34), B64 (35),
  233 + B64 (36), B64 (37), B64 (38), B64 (39),
  234 + B64 (40), B64 (41), B64 (42), B64 (43),
  235 + B64 (44), B64 (45), B64 (46), B64 (47),
  236 + B64 (48), B64 (49), B64 (50), B64 (51),
  237 + B64 (52), B64 (53), B64 (54), B64 (55),
  238 + B64 (56), B64 (57), B64 (58), B64 (59),
  239 + B64 (60), B64 (61), B64 (62), B64 (63),
  240 + B64 (64), B64 (65), B64 (66), B64 (67),
  241 + B64 (68), B64 (69), B64 (70), B64 (71),
  242 + B64 (72), B64 (73), B64 (74), B64 (75),
  243 + B64 (76), B64 (77), B64 (78), B64 (79),
  244 + B64 (80), B64 (81), B64 (82), B64 (83),
  245 + B64 (84), B64 (85), B64 (86), B64 (87),
  246 + B64 (88), B64 (89), B64 (90), B64 (91),
  247 + B64 (92), B64 (93), B64 (94), B64 (95),
  248 + B64 (96), B64 (97), B64 (98), B64 (99),
  249 + B64 (100), B64 (101), B64 (102), B64 (103),
  250 + B64 (104), B64 (105), B64 (106), B64 (107),
  251 + B64 (108), B64 (109), B64 (110), B64 (111),
  252 + B64 (112), B64 (113), B64 (114), B64 (115),
  253 + B64 (116), B64 (117), B64 (118), B64 (119),
  254 + B64 (120), B64 (121), B64 (122), B64 (123),
  255 + B64 (124), B64 (125), B64 (126), B64 (127),
  256 + B64 (128), B64 (129), B64 (130), B64 (131),
  257 + B64 (132), B64 (133), B64 (134), B64 (135),
  258 + B64 (136), B64 (137), B64 (138), B64 (139),
  259 + B64 (140), B64 (141), B64 (142), B64 (143),
  260 + B64 (144), B64 (145), B64 (146), B64 (147),
  261 + B64 (148), B64 (149), B64 (150), B64 (151),
  262 + B64 (152), B64 (153), B64 (154), B64 (155),
  263 + B64 (156), B64 (157), B64 (158), B64 (159),
  264 + B64 (160), B64 (161), B64 (162), B64 (163),
  265 + B64 (164), B64 (165), B64 (166), B64 (167),
  266 + B64 (168), B64 (169), B64 (170), B64 (171),
  267 + B64 (172), B64 (173), B64 (174), B64 (175),
  268 + B64 (176), B64 (177), B64 (178), B64 (179),
  269 + B64 (180), B64 (181), B64 (182), B64 (183),
  270 + B64 (184), B64 (185), B64 (186), B64 (187),
  271 + B64 (188), B64 (189), B64 (190), B64 (191),
  272 + B64 (192), B64 (193), B64 (194), B64 (195),
  273 + B64 (196), B64 (197), B64 (198), B64 (199),
  274 + B64 (200), B64 (201), B64 (202), B64 (203),
  275 + B64 (204), B64 (205), B64 (206), B64 (207),
  276 + B64 (208), B64 (209), B64 (210), B64 (211),
  277 + B64 (212), B64 (213), B64 (214), B64 (215),
  278 + B64 (216), B64 (217), B64 (218), B64 (219),
  279 + B64 (220), B64 (221), B64 (222), B64 (223),
  280 + B64 (224), B64 (225), B64 (226), B64 (227),
  281 + B64 (228), B64 (229), B64 (230), B64 (231),
  282 + B64 (232), B64 (233), B64 (234), B64 (235),
  283 + B64 (236), B64 (237), B64 (238), B64 (239),
  284 + B64 (240), B64 (241), B64 (242), B64 (243),
  285 + B64 (244), B64 (245), B64 (246), B64 (247),
  286 + B64 (248), B64 (249), B64 (250), B64 (251),
  287 + B64 (252), B64 (253), B64 (254), B64 (255)
  288 +};
  289 +
  290 +#if UCHAR_MAX == 255
  291 +# define uchar_in_range(c) true
  292 +#else
  293 +# define uchar_in_range(c) ((c) <= 255)
  294 +#endif
  295 +
  296 +/* Return true if CH is a character from the Base64 alphabet, and
  297 + false otherwise. Note that '=' is padding and not considered to be
  298 + part of the alphabet. */
  299 +bool
  300 +isbase64 (char ch)
  301 +{
  302 + return uchar_in_range (to_uchar (ch)) && 0 <= b64[to_uchar (ch)];
  303 +}
  304 +
  305 +/* Initialize decode-context buffer, CTX. */
  306 +void
  307 +base64_decode_ctx_init (struct base64_decode_context *ctx)
  308 +{
  309 + ctx->i = 0;
  310 +}
  311 +
  312 +/* If CTX->i is 0 or 4, there are four or more bytes in [*IN..IN_END), and
  313 + none of those four is a newline, then return *IN. Otherwise, copy up to
  314 + 4 - CTX->i non-newline bytes from that range into CTX->buf, starting at
  315 + index CTX->i and setting CTX->i to reflect the number of bytes copied,
  316 + and return CTX->buf. In either case, advance *IN to point to the byte
  317 + after the last one processed, and set *N_NON_NEWLINE to the number of
  318 + verified non-newline bytes accessible through the returned pointer. */
  319 +static inline char *
  320 +get_4 (struct base64_decode_context *ctx,
  321 + char const *restrict *in, char const *restrict in_end,
  322 + size_t *n_non_newline)
  323 +{
  324 + if (ctx->i == 4)
  325 + ctx->i = 0;
  326 +
  327 + if (ctx->i == 0)
  328 + {
  329 + char const *t = *in;
  330 + if (4 <= in_end - *in && memchr (t, '\n', 4) == NULL)
  331 + {
  332 + /* This is the common case: no newline. */
  333 + *in += 4;
  334 + *n_non_newline = 4;
  335 + return (char *) t;
  336 + }
  337 + }
  338 +
  339 + {
  340 + /* Copy non-newline bytes into BUF. */
  341 + char const *p = *in;
  342 + while (p < in_end)
  343 + {
  344 + char c = *p++;
  345 + if (c != '\n')
  346 + {
  347 + ctx->buf[ctx->i++] = c;
  348 + if (ctx->i == 4)
  349 + break;
  350 + }
  351 + }
  352 +
  353 + *in = p;
  354 + *n_non_newline = ctx->i;
  355 + return ctx->buf;
  356 + }
  357 +}
  358 +
  359 +#define return_false \
  360 + do \
  361 + { \
  362 + *outp = out; \
  363 + return false; \
  364 + } \
  365 + while (false)
  366 +
  367 +/* Decode up to four bytes of base64-encoded data, IN, of length INLEN
  368 + into the output buffer, *OUT, of size *OUTLEN bytes. Return true if
  369 + decoding is successful, false otherwise. If *OUTLEN is too small,
  370 + as many bytes as possible are written to *OUT. On return, advance
  371 + *OUT to point to the byte after the last one written, and decrement
  372 + *OUTLEN to reflect the number of bytes remaining in *OUT. */
  373 +static inline bool
  374 +decode_4 (char const *restrict in, size_t inlen,
  375 + char *restrict *outp, size_t *outleft)
  376 +{
  377 + char *out = *outp;
  378 + if (inlen < 2)
  379 + return false;
  380 +
  381 + if (!isbase64 (in[0]) || !isbase64 (in[1]))
  382 + return false;
  383 +
  384 + if (*outleft)
  385 + {
  386 + *out++ = ((b64[to_uchar (in[0])] << 2)
  387 + | (b64[to_uchar (in[1])] >> 4));
  388 + --*outleft;
  389 + }
  390 +
  391 + if (inlen == 2)
  392 + return_false;
  393 +
  394 + if (in[2] == '=')
  395 + {
  396 + if (inlen != 4)
  397 + return_false;
  398 +
  399 + if (in[3] != '=')
  400 + return_false;
  401 + }
  402 + else
  403 + {
  404 + if (!isbase64 (in[2]))
  405 + return_false;
  406 +
  407 + if (*outleft)
  408 + {
  409 + *out++ = (((b64[to_uchar (in[1])] << 4) & 0xf0)
  410 + | (b64[to_uchar (in[2])] >> 2));
  411 + --*outleft;
  412 + }
  413 +
  414 + if (inlen == 3)
  415 + return_false;
  416 +
  417 + if (in[3] == '=')
  418 + {
  419 + if (inlen != 4)
  420 + return_false;
  421 + }
  422 + else
  423 + {
  424 + if (!isbase64 (in[3]))
  425 + return_false;
  426 +
  427 + if (*outleft)
  428 + {
  429 + *out++ = (((b64[to_uchar (in[2])] << 6) & 0xc0)
  430 + | b64[to_uchar (in[3])]);
  431 + --*outleft;
  432 + }
  433 + }
  434 + }
  435 +
  436 + *outp = out;
  437 + return true;
  438 +}
  439 +
  440 +/* Decode base64-encoded input array IN of length INLEN to output array
  441 + OUT that can hold *OUTLEN bytes. The input data may be interspersed
  442 + with newlines. Return true if decoding was successful, i.e. if the
  443 + input was valid base64 data, false otherwise. If *OUTLEN is too
  444 + small, as many bytes as possible will be written to OUT. On return,
  445 + *OUTLEN holds the length of decoded bytes in OUT. Note that as soon
  446 + as any non-alphabet, non-newline character is encountered, decoding
  447 + is stopped and false is returned. If INLEN is zero, then process
  448 + only whatever data is stored in CTX.
  449 +
  450 + Initially, CTX must have been initialized via base64_decode_ctx_init.
  451 + Subsequent calls to this function must reuse whatever state is recorded
  452 + in that buffer. It is necessary for when a quadruple of base64 input
  453 + bytes spans two input buffers.
  454 +
  455 + If CTX is NULL then newlines are treated as garbage and the input
  456 + buffer is processed as a unit. */
  457 +
  458 +bool
  459 +base64_decode_ctx (struct base64_decode_context *ctx,
  460 + const char *restrict in, size_t inlen,
  461 + char *restrict out, size_t *outlen)
  462 +{
  463 + size_t outleft = *outlen;
  464 + bool ignore_newlines = ctx != NULL;
  465 + bool flush_ctx = false;
  466 + unsigned int ctx_i = 0;
  467 +
  468 + if (ignore_newlines)
  469 + {
  470 + ctx_i = ctx->i;
  471 + flush_ctx = inlen == 0;
  472 + }
  473 +
  474 +
  475 + while (true)
  476 + {
  477 + size_t outleft_save = outleft;
  478 + if (ctx_i == 0 && !flush_ctx)
  479 + {
  480 + while (true)
  481 + {
  482 + /* Save a copy of outleft, in case we need to re-parse this
  483 + block of four bytes. */
  484 + outleft_save = outleft;
  485 + if (!decode_4 (in, inlen, &out, &outleft))
  486 + break;
  487 +
  488 + in += 4;
  489 + inlen -= 4;
  490 + }
  491 + }
  492 +
  493 + if (inlen == 0 && !flush_ctx)
  494 + break;
  495 +
  496 + /* Handle the common case of 72-byte wrapped lines.
  497 + This also handles any other multiple-of-4-byte wrapping. */
  498 + if (inlen && *in == '\n' && ignore_newlines)
  499 + {
  500 + ++in;
  501 + --inlen;
  502 + continue;
  503 + }
  504 +
  505 + /* Restore OUT and OUTLEFT. */
  506 + out -= outleft_save - outleft;
  507 + outleft = outleft_save;
  508 +
  509 + {
  510 + char const *in_end = in + inlen;
  511 + char const *non_nl;
  512 +
  513 + if (ignore_newlines)
  514 + non_nl = get_4 (ctx, &in, in_end, &inlen);
  515 + else
  516 + non_nl = in; /* Might have nl in this case. */
  517 +
  518 + /* If the input is empty or consists solely of newlines (0 non-newlines),
  519 + then we're done. Likewise if there are fewer than 4 bytes when not
  520 + flushing context and not treating newlines as garbage. */
  521 + if (inlen == 0 || (inlen < 4 && !flush_ctx && ignore_newlines))
  522 + {
  523 + inlen = 0;
  524 + break;
  525 + }
  526 + if (!decode_4 (non_nl, inlen, &out, &outleft))
  527 + break;
  528 +
  529 + inlen = in_end - in;
  530 + }
  531 + }
  532 +
  533 + *outlen -= outleft;
  534 +
  535 + return inlen == 0;
  536 +}
  537 +
  538 +/* Allocate an output buffer in *OUT, and decode the base64 encoded
  539 + data stored in IN of size INLEN to the *OUT buffer. On return, the
  540 + size of the decoded data is stored in *OUTLEN. OUTLEN may be NULL,
  541 + if the caller is not interested in the decoded length. *OUT may be
  542 + NULL to indicate an out of memory error, in which case *OUTLEN
  543 + contains the size of the memory block needed. The function returns
  544 + true on successful decoding and memory allocation errors. (Use the
  545 + *OUT and *OUTLEN parameters to differentiate between successful
  546 + decoding and memory error.) The function returns false if the
  547 + input was invalid, in which case *OUT is NULL and *OUTLEN is
  548 + undefined. */
  549 +bool
  550 +base64_decode_alloc_ctx (struct base64_decode_context *ctx,
  551 + const char *in, size_t inlen, char **out,
  552 + size_t *outlen)
  553 +{
  554 + /* This may allocate a few bytes too many, depending on input,
  555 + but it's not worth the extra CPU time to compute the exact size.
  556 + The exact size is 3 * inlen / 4, minus 1 if the input ends
  557 + with "=" and minus another 1 if the input ends with "==".
  558 + Dividing before multiplying avoids the possibility of overflow. */
  559 + size_t needlen = 3 * (inlen / 4) + 2;
  560 +
  561 + *out = malloc (needlen);
  562 + if (!*out)
  563 + return true;
  564 +
  565 + if (!base64_decode_ctx (ctx, in, inlen, *out, &needlen))
  566 + {
  567 + free (*out);
  568 + *out = NULL;
  569 + return false;
  570 + }
  571 +
  572 + if (outlen)
  573 + *outlen = needlen;
  574 +
  575 + return true;
  576 +}
  1 +/* -*- buffer-read-only: t -*- vi: set ro: */
  2 +/* DO NOT EDIT! GENERATED AUTOMATICALLY! */
  3 +/* base64.h -- Encode binary data using printable characters.
  4 + Copyright (C) 2004, 2005, 2006, 2009, 2010 Free Software Foundation, Inc.
  5 + Written by Simon Josefsson.
  6 +
  7 + This program is free software; you can redistribute it and/or modify
  8 + it under the terms of the GNU General Public License as published by
  9 + the Free Software Foundation; either version 3, or (at your option)
  10 + any later version.
  11 +
  12 + This program is distributed in the hope that it will be useful,
  13 + but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 + GNU General Public License for more details.
  16 +
  17 + You should have received a copy of the GNU General Public License
  18 + along with this program; if not, write to the Free Software Foundation,
  19 + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
  20 +
  21 +/* Define to the equivalent of the C99 'restrict' keyword, or to
  22 + * nothing if this is not supported. Do not define if restrict is
  23 + * supported directly. */
  24 +#define restrict __restrict
  25 +/* Work around a bug in Sun C++: it does not support _Restrict or
  26 + * __restrict__, even though the corresponding Sun C compiler ends up with
  27 + * "#define restrict _Restrict" or "#define restrict __restrict__" in the
  28 + * previous line. Perhaps some future version of Sun C++ will work with
  29 + * restrict; if so, hopefully it defines __RESTRICT like Sun C does. */
  30 +#if defined __SUNPRO_CC && !defined __RESTRICT
  31 +# define _Restrict
  32 +# define __restrict__
  33 +#endif
  34 +
  35 +#ifndef BASE64_H
  36 +# define BASE64_H
  37 +
  38 +/* Get size_t. */
  39 +# include <stddef.h>
  40 +
  41 +/* Get bool. */
  42 +# include <stdbool.h>
  43 +
  44 +/* This uses that the expression (n+(k-1))/k means the smallest
  45 + integer >= n/k, i.e., the ceiling of n/k. */
  46 +# define BASE64_LENGTH(inlen) ((((inlen) + 2) / 3) * 4)
  47 +
  48 +struct base64_decode_context
  49 +{
  50 + unsigned int i;
  51 + char buf[4];
  52 +};
  53 +
  54 +extern bool isbase64 (char ch);
  55 +
  56 +extern void base64_encode (const char *restrict in, size_t inlen,
  57 + char *restrict out, size_t outlen);
  58 +
  59 +extern size_t base64_encode_alloc (const char *in, size_t inlen, char **out);
  60 +
  61 +extern void base64_decode_ctx_init (struct base64_decode_context *ctx);
  62 +
  63 +extern bool base64_decode_ctx (struct base64_decode_context *ctx,
  64 + const char *restrict in, size_t inlen,
  65 + char *restrict out, size_t *outlen);
  66 +
  67 +extern bool base64_decode_alloc_ctx (struct base64_decode_context *ctx,
  68 + const char *in, size_t inlen,
  69 + char **out, size_t *outlen);
  70 +
  71 +#define base64_decode(in, inlen, out, outlen) \
  72 + base64_decode_ctx (NULL, in, inlen, out, outlen)
  73 +
  74 +#define base64_decode_alloc(in, inlen, out, outlen) \
  75 + base64_decode_alloc_ctx (NULL, in, inlen, out, outlen)
  76 +
  77 +#endif /* BASE64_H */
  1 +#include "bigpoint_cclass.h"
  2 +
  3 +#include <stdarg.h>
  4 +#include <string.h>
  5 +#include <stdlib.h>
  6 +#include <json/json.h>
  7 +
  8 +
  9 +void *
  10 +new(const void * _class, ...)
  11 +{
  12 + const struct BIGPOINT_CCLASS * class = _class;
  13 + void * object = calloc(1, class->size);
  14 +
  15 + * (const struct BIGPOINT_CCLASS **) object = class;
  16 +
  17 + if (class->__construct) {
  18 + va_list params;
  19 +
  20 + va_start(params, _class);
  21 + class->__construct(object, &params);
  22 + va_end(params);
  23 + }
  24 +
  25 + return object;
  26 +}
  27 +
  28 +void *
  29 +newFromJson(const void * _class, struct json_object * json)
  30 +{
  31 + const struct BIGPOINT_CCLASS * class = _class;
  32 + void * object = calloc(1, class->size);
  33 +
  34 + * (const struct BIGPOINT_CCLASS **) object = class;
  35 +
  36 + if (class->__jsonConst && json) {
  37 + class->__jsonConst(object, json);
  38 + }
  39 +
  40 + return object;
  41 +}
  42 +
  43 +void
  44 +delete(void * _object)
  45 +{
  46 + const struct BIGPOINT_CCLASS ** class = _object;
  47 +
  48 + if (_object && *class && (*class)->__destruct) {
  49 + (*class)->__destruct(_object);
  50 + }
  51 +
  52 + free(_object);
  53 +}
  54 +
  55 +struct json_object *
  56 +toJson(void * _object)
  57 +{
  58 + const struct BIGPOINT_CCLASS ** class = _object;
  59 +
  60 + if (_object && *class && (*class)->__toJson) {
  61 + return (*class)->__toJson(_object);
  62 + }
  63 +
  64 + return NULL;
  65 +}
  66 +
  67 +// vim: set et ts=4 sw=4:
  1 +#ifndef __BIGPOINT_CCLASS_H__
  2 +#define __BIGPOINT_CCLASS_H__
  3 +
  4 +#include <stdarg.h>
  5 +#include <sys/types.h>
  6 +#include <json/json.h>
  7 +
  8 +typedef void (* ctor)(void*, va_list*);
  9 +typedef void (* dtor)(void*);
  10 +
  11 +struct BIGPOINT_CCLASS {
  12 + size_t size;
  13 + void (* __construct)(void * _this, va_list * params);
  14 + void (* __jsonConst)(void * _this, struct json_object * json);
  15 + void (* __destruct)(void * _this);
  16 + struct json_object * (* __toJson)(void * _this);
  17 +};
  18 +
  19 +void *
  20 +new(const void * _class, ...);
  21 +
  22 +void *
  23 +newFromJson(const void * _class, struct json_object * json);
  24 +
  25 +void
  26 +delete(void * _object);
  27 +
  28 +struct json_object *
  29 +toJson(void * _object);
  30 +
  31 +#endif//__BIGPOINT_CCLASS_H__
  32 +
  33 +// vim: set et ts=4 sw=4:
  1 +#include <stdarg.h>
  2 +#include <stdlib.h>
  3 +#include <fcntl.h>
  4 +#include <string.h>
  5 +#include <sys/types.h>
  6 +#include <sys/stat.h>
  7 +#include <mcrypt.h>
  8 +#include <mhash.h>
  9 +
  10 +#include "bigpoint_crypt.h"
  11 +
  12 +
  13 +static
  14 +void
  15 +__construct(struct BIGPOINT_CRYPT * _this, va_list * params)
  16 +{
  17 + _this->algorithm = va_arg(* params, const char * const);
  18 + _this->mode = va_arg(* params, const char * const);
  19 +
  20 + _this->mcrypt = mcrypt_module_open(
  21 + (char *)_this->algorithm,
  22 + NULL,
  23 + (char *)_this->mode,
  24 + NULL);
  25 +
  26 + _this->ivsize = mcrypt_enc_get_iv_size(_this->mcrypt);
  27 + _this->keysize = mcrypt_enc_get_key_size(_this->mcrypt);
  28 +}
  29 +
  30 +static
  31 +void
  32 +__destruct(struct BIGPOINT_CRYPT * _this)
  33 +{
  34 + if (_this->iv) {
  35 + free(_this->iv);
  36 + }
  37 +
  38 + mcrypt_module_close(_this->mcrypt);
  39 +}
  40 +
  41 +static const
  42 +struct BIGPOINT_CCLASS _bigpoint_crypt = {
  43 + sizeof(struct BIGPOINT_CRYPT),
  44 + (ctor)__construct,
  45 + NULL,
  46 + (dtor)__destruct,
  47 + NULL
  48 +};
  49 +
  50 +const struct BIGPOINT_CCLASS * const BIGPOINT_CRYPT = &_bigpoint_crypt;
  51 +
  52 +static
  53 +void
  54 +mcrypt_close(MCRYPT * mcrypt)
  55 +{
  56 + mcrypt_free(*mcrypt);
  57 + *mcrypt = NULL;
  58 +}
  59 +
  60 +void *
  61 +bigpoint_crypt_createIv(struct BIGPOINT_CRYPT * _this)
  62 +{
  63 + int urandom;
  64 + size_t rsize = 0;
  65 + void * iv = NULL;
  66 +
  67 + iv = calloc(_this->ivsize, sizeof(char));
  68 +
  69 + urandom = open("/dev/urandom", O_RDONLY);
  70 + rsize = read(urandom, iv, _this->ivsize);
  71 +
  72 + if (_this->ivsize != rsize) {
  73 + free(iv);
  74 + iv = NULL;
  75 + }
  76 +
  77 + return iv;
  78 +}
  79 +
  80 +static
  81 +void *
  82 +createKey(struct BIGPOINT_CRYPT * _this, const char * const password)
  83 +{
  84 + void * key = NULL;
  85 +
  86 + key = calloc(_this->keysize, sizeof(char));
  87 +
  88 + mhash_keygen(
  89 + KEYGEN_MCRYPT,
  90 + MHASH_SHA256,
  91 + mhash_keygen_count(),
  92 + key,
  93 + _this->keysize,
  94 + NULL,
  95 + 0,
  96 + (char *)password, // @TODO: bad karma...now this might change password.
  97 + strlen(password));
  98 +
  99 + return key;
  100 +}
  101 +
  102 +void *
  103 +bigpoint_crypt_encrypt(
  104 + struct BIGPOINT_CRYPT * _this,
  105 + const void * const data,
  106 + const char * const password,
  107 + size_t * length)
  108 +{
  109 + char * encrypted;
  110 + void * iv;
  111 + void * key;
  112 +
  113 + key = createKey(_this, password);
  114 + if(_this->iv) {
  115 + iv = _this->iv;
  116 + } else {
  117 + iv = bigpoint_crypt_createIv(_this);
  118 + }
  119 +
  120 + mcrypt_generic_init(_this->mcrypt, key, _this->keysize, iv);
  121 +
  122 + encrypted = calloc(_this->ivsize + *length, sizeof(char));
  123 + memcpy(encrypted, iv, _this->ivsize);
  124 + memcpy(encrypted + _this->ivsize, data, *length);
  125 +
  126 + mcrypt_generic(_this->mcrypt, encrypted + _this->ivsize, *length);
  127 + mcrypt_generic_deinit(_this->mcrypt);
  128 + *length += _this->ivsize;
  129 +
  130 + free(key);
  131 + if (_this->iv != iv) {
  132 + free(iv);
  133 + }
  134 +
  135 + return encrypted;
  136 +}
  137 +
  138 +void *
  139 +bigpoint_crypt_decrypt(
  140 + struct BIGPOINT_CRYPT * _this,
  141 + const void * const data,
  142 + const char * const password,
  143 + size_t * length)
  144 +{
  145 + char * decrypted;
  146 + void * iv;
  147 + void * key;
  148 +
  149 + key = createKey(_this, password);
  150 + iv = calloc(_this->ivsize, sizeof(char));
  151 + memcpy(iv, data, _this->ivsize);
  152 +
  153 + mcrypt_generic_init(_this->mcrypt, key, _this->keysize, iv);
  154 +
  155 + *length -= _this->ivsize;
  156 + decrypted = calloc(*length, sizeof(char));
  157 + memcpy(decrypted, data + _this->ivsize, *length);
  158 +
  159 + mdecrypt_generic(_this->mcrypt, decrypted, *length);
  160 + mcrypt_generic_deinit(_this->mcrypt);
  161 +
  162 + free(key);
  163 + free(iv);
  164 +
  165 + return decrypted;
  166 +}
  167 +
  168 +// vim: set et ts=4 sw=4:
  1 +#ifndef __BIGPOINT_CRYPT_H__
  2 +#define __BIGPOINT_CRYPT_H__
  3 +
  4 +#include <sys/types.h>
  5 +
  6 +#include "bigpoint_cclass.h"
  7 +
  8 +
  9 +struct BIGPOINT_CRYPT {
  10 + const struct BIGPOINT_CCLASS * const class;
  11 + const char * algorithm;
  12 + const char * mode;
  13 + MCRYPT mcrypt;
  14 + size_t ivsize;
  15 + size_t keysize;
  16 + void * iv;
  17 +};
  18 +
  19 +extern const struct BIGPOINT_CCLASS * const BIGPOINT_CRYPT;
  20 +
  21 +void * bigpoint_crypt_encrypt(
  22 + struct BIGPOINT_CRYPT * _this,
  23 + const void * const data,
  24 + const char * const password,
  25 + size_t * length);
  26 +
  27 +void * bigpoint_crypt_decrypt(
  28 + struct BIGPOINT_CRYPT * _this,
  29 + const void * const data,
  30 + const char * const password,
  31 + size_t * length);
  32 +
  33 +void * bigpoint_crypt_createIv(
  34 + struct BIGPOINT_CRYPT * _this);
  35 +
  36 +void bigpoint_crypt_setIv(
  37 + struct BIGPOINT_CRYPT * _this,
  38 + const void * const iv);
  39 +
  40 +void bigpoint_crypt_setIvsize(
  41 + struct BIGPOINT_CRYPT * _this,
  42 + const size_t size);
  43 +
  44 +void bigpoint_crypt_setKeysize(
  45 + struct BIGPOINT_CRYPT * _this,
  46 + const size_t size);
  47 +
  48 +#endif//__BIGPOINT_CRYPT_H__
  49 +// vim: set et ts=4 sw=4:
  1 +#include <stdlib.h>
  2 +#include <string.h>
  3 +#include <sys/types.h>
  4 +#include <json/json.h>
  5 +
  6 +#include "bigpoint_dyntype.h"
  7 +
  8 +
  9 +static
  10 +void
  11 +__construct(struct BIGPOINT_DYNTYPE * _this, va_list * params)
  12 +{
  13 + _this->type = va_arg(* params, enum BIGPOINT_DYNTYPE_TYPES);
  14 + _this->size = va_arg(* params, size_t);
  15 +
  16 + _this->data = calloc(_this->size, sizeof(char));
  17 + memcpy(_this->data, va_arg(* params, void *), _this->size);
  18 +}
  19 +
  20 +static
  21 +void
  22 +__destruct(struct BIGPOINT_DYNTYPE * _this)
  23 +{
  24 + if (_this && _this->data) {
  25 + free(_this->data);
  26 + }
  27 +}
  28 +
  29 +static
  30 +struct json_object *
  31 +__toJson(struct BIGPOINT_DYNTYPE * _this)
  32 +{
  33 + struct json_object * json = NULL;
  34 +
  35 + /**
  36 + * @TODO: make a smart implementation here base on the type of the
  37 + * actual object.
  38 + */
  39 + return json;
  40 +}
  41 +
  42 +static
  43 +void
  44 +__jsonConst(struct BIGPOINT_DYNTYPE * _this, struct json_object * json)
  45 +{
  46 + /**
  47 + * @TODO: initialize by json....
  48 + */
  49 +}
  50 +
  51 +static const
  52 +struct BIGPOINT_CCLASS _bigpoint_dyntype = {
  53 + sizeof(struct BIGPOINT_DYNTYPE),
  54 + (ctor)__construct,
  55 + __jsonConst,
  56 + (dtor)__destruct,
  57 + __toJson
  58 +};
  59 +
  60 +const struct BIGPOINT_CCLASS * const BIGPOINT_DYNTYPE = &_bigpoint_dyntype;
  61 +
  62 +// vim: set et ts=4 sw=4:
  1 +#ifndef __BIGPOINT_DYNTYPE_H__
  2 +#define __BIGPOINT_DYNTYPE_H__
  3 +
  4 +#include <sys/types.h>
  5 +
  6 +#include "bigpoint_cclass.h"
  7 +
  8 +
  9 +enum BIGPOINT_DYNTYPE_TYPES {
  10 + BIGPOINT_DYNTYPE_BOOLEAN = 0,
  11 + BIGPOINT_DYNTYPE_INT,
  12 + BIGPOINT_DYNTYPE_FLOAT,
  13 + BIGPOINT_DYNTYPE_STRING,
  14 + BIGPOINT_DYNTYPE_ARRAY,
  15 + BIGPOINT_DYNTYPE_OBJECT
  16 +};
  17 +
  18 +
  19 +struct BIGPOINT_DYNTYPE {
  20 + const struct BIGPOINT_CCLASS * const class;
  21 + enum BIGPOINT_DYNTYPE_TYPES type;
  22 + size_t size;
  23 + void * data;
  24 +};
  25 +
  26 +extern const struct BIGPOINT_CCLASS * const BIGPOINT_DYNTYPE;
  27 +
  28 +#endif//__BIGPOINT_DYNTYPE_H__
  29 +
  30 +// vim: set et ts=4 sw=4:
  1 +#include <json/json.h>
  2 +
  3 +#include "bigpoint_container_packet.h"
  4 +
  5 +
  6 +static
  7 +void
  8 +__construct(struct BIGPOINT_PACKET * _this, va_list * params)
  9 +{
  10 + bigpoint_container_packet_set_default_content(_this);
  11 +}
  12 +
  13 +static
  14 +void
  15 +__jsonConst(struct BIGPOINT_PACKET * _this, struct json_object * json)
  16 +{
  17 + struct json_object * header = NULL;
  18 + struct json_object * data = NULL;
  19 +
  20 + if (! json_type_array == json_object_get_type(json)) {
  21 + bigpoint_packet_set_default_content(_this);
  22 + return;
  23 + }
  24 +
  25 + header = json_object_array_get_idx(json, 0);
  26 + data = json_object_array_get_idx(json, 1);
  27 +
  28 + if (! (header && data)) {
  29 + bigpoint_packet_set_default_content(_this);
  30 + return;
  31 + }
  32 +
  33 + bigpoint_packet_setHeader(_this, newFromJson(BIGPOINT_DYNTYPE, header));
  34 + bigpoint_packet_setData(_this, newFromJson(BIGPOINT_DYNTYPE, data));
  35 +}
  36 +
  37 +static
  38 +void
  39 +__destruct(struct BIGPOINT_PACKET * _this)
  40 +{
  41 +}
  42 +
  43 +static
  44 +struct json_object *
  45 +__toJson(struct BIGPOINT_PACKET * _this)
  46 +{
  47 + struct json_object * json = json_object_new_array();
  48 +
  49 + json_object_array_add(json, toJson(bigpoint_packet_getHeader(_this)));
  50 + json_object_array_add(json, toJson(bigpoint_packet_getData(_this)));
  51 +
  52 + return json;
  53 +}
  54 +
  55 +static const
  56 +struct BIGPOINT_CLASS _bigpoint_packet = {
  57 + sizeof(struct BIGPOINT_PACKET),
  58 + (ctor)__construct,
  59 + __jsonConst,
  60 + (dtor)__destruct,
  61 + __toJson
  62 +};
  63 +
  64 +const struct BIGPOINT_CCLASS * const BIGPOINT_PACKET = &_bigpoint_packet;
  65 +
  66 +void *
  67 +bigpoint_packet_getHeader(
  68 + struct BIGPOINT_PACKET * _this)
  69 +{
  70 + return _this->content[BIGPOINT_PACKET_HEADER];
  71 +}
  72 +
  73 +void *
  74 +bigpoint_packet_getData(
  75 + struct BIGPOINT_PACKET * _this)
  76 +{
  77 + return _this->content[BIGPOINT_PACKET_DATA];
  78 +}
  79 +
  80 +void bigpoint_packet_setHeader(
  81 + struct BIGPOINT_PACKET * _this,
  82 + struct BIGPOINT_DYNTYPE * header)
  83 +{
  84 + _this->content[BIGPOINT_PACKET_HEADER] = header;
  85 +}
  86 +
  87 +void bigpoint_packet_setData(
  88 + struct BIGPOINT_PACKET * _this,
  89 + struct BIGPOINT_DYNTYPE * data)
  90 +{
  91 + _this->content[BIGPOINT_PACKET_DATA] = data;
  92 +}
  93 +
  94 +void
  95 +bigpoint_container_packet_set_default_content(
  96 + struct BIGPOINT_PACKET * _this)
  97 +{
  98 + _this->content[BIGPOINT_PACKET_HEADER] = NULL;
  99 + _this->content[BIGPOINT_PACKET_DATA] = NULL;
  100 +}
  101 +
  102 +// vim: set et ts=4 sw=4:
  1 +#ifndef __BIGPOINT_PACKET_H__
  2 +#define __BIGPOINT_PACKET_H__
  3 +
  4 +#include "bigpoint_cclass.h"
  5 +#include "bigpoint_dyntype.h"
  6 +
  7 +
  8 +enum BIGPOINT_PACKET_CONTENT_KEYS {
  9 + BIGPOINT_PACKET_HEADER = 0,
  10 + BIGPOINT_PACKET_DATA
  11 +};
  12 +
  13 +struct BIGPOINT_PACKET {
  14 + const struct BIGPOINT_CCLASS * const class;
  15 + struct BIGPOINT_DYNTYPE * content[2];
  16 +};
  17 +
  18 +extern const struct BIGPOINT_CCLASS * const BIGPOINT_PACKET;
  19 +
  20 +void * bigpoint_packet_getHeader(
  21 + struct BIGPOINT_PACKET * _this);
  22 +
  23 +void * bigpoint_packet_getData(
  24 + struct BIGPOINT_PACKET * _this);
  25 +
  26 +void bigpoint_packet_setHeader(
  27 + struct BIGPOINT_PACKET * _this,
  28 + struct BIGPOINT_DYNTYPE * header);
  29 +
  30 +void bigpoint_packet_setData(
  31 + struct BIGPOINT_PACKET * _this,
  32 + struct BIGPOINT_DYNTYPE * data);
  33 +
  34 +void bigpoint_packet_set_default_content(
  35 + struct BIGPOINT_PACKET * _this);
  36 +
  37 +#endif//__BIGPOINT_PACKET_H__
  38 +
  39 +// vim: set et ts=4 sw=4:
  1 +#include "bigpoint_token_cryptdec"
  2 +
  3 +static
  4 +void
  5 +__construct(struct BIGPOINT_TOKEN_CRYPTDEC * _this, va_list * params)
  6 +{
  7 + _this->containerFactory = va_arg(* params, struct BIGPOINT_CONTANER_FACTORY *);
  8 + _this->crypt = va_arg(* params, struct BIGPOINT_CRYPT *);
  9 +}
  10 +
  11 +// vim: set et ts=4 sw=4:
  1 +#ifndef __BIGPOINT_TOKEN_CRPYTDEC_H__
  2 +#define __BIGPOINT_TOKEN_CRPYTDEC_H__
  3 +
  4 +#include "bigpoint_cclass.h"
  5 +
  6 +
  7 +struct BIGPOINT_TOKEN_CRYPTDEC {
  8 + const struct BIGPOINT_CCLASS * const class;
  9 + struct BIGPOINT_CONTAINTER_FACTORY * containerFactory;
  10 + struct BIGPOINT_CRYPT * crypt;
  11 +}
  12 +
  13 +extern const struct BIGPOINT_CCLASS * const BIGPOINT_TOKEN_CRYPTDEC;
  14 +
  15 +#endif//__BIGPOINT_TOKEN_CRPYTDEC_H__
  16 +
  17 +// vim: set et ts=4 sw=4:
  1 +#include <mcrypt.h>
  2 +#include <string.h>
  3 +#include <stdlib.h>
  4 +#include <stdio.h>
  5 +#include <sys/types.h>
  6 +
  7 +#include "bigpoint_cclass.h"
  8 +#include "bigpoint_crypt.h"
  9 +#include "base64.h"
  10 +
  11 +
  12 +int
  13 +main(int argc, char * argv[])
  14 +{
  15 + char b64d[] = "J4rYV+oJ9+EzoyLy/o8aolRSw51DzDhTyeht/tcdUA6hNNxaVFrW/FXVTfWXzkZgW1oc1D2vwkfQ80PD+iWzcw";
  16 + char pass[] = "1234";
  17 + char * data = NULL;
  18 + char * decrypted = NULL;
  19 + size_t length = strlen(b64d);
  20 +
  21 + struct BIGPOINT_CRYPT * crypt = NULL;
  22 +
  23 + data = calloc(length, sizeof(char));
  24 + base64_decode(b64d, length, data, &length);
  25 +
  26 + data = realloc(data, length + 1);
  27 + data[length] = '\0';
  28 +
  29 + crypt = new(BIGPOINT_CRYPT, MCRYPT_RIJNDAEL_256, MCRYPT_CFB);
  30 + decrypted = bigpoint_crypt_decrypt(crypt, data, pass, &length);
  31 + delete(crypt);
  32 + free(data);
  33 +
  34 + printf("%s\n", decrypted);
  35 + free(decrypted);
  36 +
  37 + return 0;
  38 +}
  39 +
  40 +// vim: set et ts=4 sw=4:
  1 +#include <mcrypt.h>
  2 +#include <string.h>
  3 +#include <stdlib.h>
  4 +#include <stdio.h>
  5 +#include <sys/types.h>
  6 +
  7 +#include "bigpoint_cclass.h"
  8 +#include "bigpoint_crypt.h"
  9 +#include "base64.h"
  10 +
  11 +
  12 +int
  13 +main(int argc, char * argv[])
  14 +{
  15 + char data[] = "ein weiterer test";
  16 + char pass[] = "1234";
  17 + char * b64d = NULL;
  18 + char * encrypted = NULL;
  19 + size_t length = strlen(data);
  20 +
  21 + struct BIGPOINT_CRYPT * crypt = NULL;
  22 +
  23 + crypt = new(BIGPOINT_CRYPT, MCRYPT_RIJNDAEL_256, MCRYPT_CFB);
  24 + encrypted = bigpoint_crypt_encrypt(crypt, data, pass, &length);
  25 + delete(crypt);
  26 +
  27 + b64d = calloc(BASE64_LENGTH(length), sizeof(char));
  28 + base64_encode(encrypted, length, b64d, BASE64_LENGTH(length));
  29 + free(encrypted);
  30 +
  31 + b64d = realloc(b64d, BASE64_LENGTH(length) + 1);
  32 + b64d[BASE64_LENGTH(length)] = '\0';
  33 +
  34 + printf("%s\n", b64d);
  35 + free(b64d);
  36 +
  37 + return 0;
  38 +}
  39 +
  40 +// vim: set et ts=4 sw=4:
  1 +#include <stdio.h>
  2 +#include <string.h>
  3 +
  4 +#include "bigpoint_cclass.h"
  5 +#include "bigpoint_dyntype.h"
  6 +
  7 +
  8 +int
  9 +main(int argc, char * argv[])
  10 +{
  11 + char string[] = "ein weiterer test";
  12 + int integer = 42;
  13 + float floating = 4.3;
  14 +
  15 + char * rstring = NULL;
  16 + long rint = 0;
  17 + double rfloat = 0.0;
  18 +
  19 + struct BIGPOINT_DYNTYPE * dynstring =
  20 + new(BIGPOINT_DYNTYPE, BIGPOINT_DYNTYPE_STRING, strlen(string) + 1, string);
  21 + struct BIGPOINT_DYNTYPE * dynint =
  22 + new(BIGPOINT_DYNTYPE, BIGPOINT_DYNTYPE_INT, sizeof(long), (long)integer);
  23 + struct BIGPOINT_DYNTYPE * dynfloat =
  24 + new(BIGPOINT_DYNTYPE, BIGPOINT_DYNTYPE_FLOAT, sizeof(double), (double)floating);
  25 +
  26 + bigpoint_dyntype_get(dynstring, rstring);
  27 + bigpoint_dyntype_get(dynint, rint);
  28 + bigpoint_dyntype_get(dynfloat, rfloat);
  29 +
  30 + printf("%s\n", rstring);
  31 + printf("%ld\n", rint);
  32 + printf("%lf\n", rfloat);
  33 +
  34 + delete(dynstring);
  35 + delete(dynint);
  36 + delete(dynfloat);
  37 +
  38 + return 0;
  39 +}
  40 +
  41 +// vim: set et ts=4 sw=4:
Please register or login to post a comment