1 /**

     2  * XML Security Library (http://www.aleksey.com/xmlsec).

     3  *

     4  * Base64 encode/decode transform and utility functions.

     5  *

     6  * This is free software; see Copyright file in the source

     7  * distribution for preciese wording.

     8  * 

     9  * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>

    10  * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

    11  */

    12 #include "xmlsec_globals.h"

    13 

    14 #include <stdlib.h>

    15 #include <stdio.h>

    16 #include <string.h>

    17 

    18 #include <libxml2_tree.h>

    19 #include <libxml2_globals.h>

    20 

    21 

    22 #include "xmlsec_xmlsec.h"

    23 #include "xmlsec_keys.h"

    24 #include "xmlsec_transforms.h"

    25 #include "xmlsec_base64.h"

    26 #include "xmlsec_errors.h"

    27 

    28 

    29 /* 

    30  * the table to map numbers to base64 

    31  */

    32 static const xmlSecByte base64[] =

    33 {  

    34 /*   0    1    2    3    4    5    6    7   */

    35     'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', /* 0 */

    36     'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', /* 1 */

    37     'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', /* 2 */

    38     'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', /* 3 */

    39     'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', /* 4 */

    40     'o', 'p', 'q', 'r', 's', 't', 'u', 'v', /* 5 */

    41     'w', 'x', 'y', 'z', '0', '1', '2', '3', /* 6 */

    42     '4', '5', '6', '7', '8', '9', '+', '/'  /* 7 */

    43 };

    44 

    45 

    46 /* few macros to simplify the code */

    47 #define xmlSecBase64Encode1(a) 		(((a) >> 2) & 0x3F)

    48 #define xmlSecBase64Encode2(a, b) 	((((a) << 4) & 0x30) + (((b) >> 4) & 0x0F))

    49 #define xmlSecBase64Encode3(b, c) 	((((b) << 2) & 0x3c) + (((c) >> 6) & 0x03))

    50 #define xmlSecBase64Encode4(c)		((c) & 0x3F)

    51 

    52 #define xmlSecBase64Decode1(a, b)	(((a) << 2) | (((b) & 0x3F) >> 4))

    53 #define xmlSecBase64Decode2(b, c)	(((b) << 4) | (((c) & 0x3F) >> 2))

    54 #define xmlSecBase64Decode3(c, d)	(((c) << 6) | ((d) & 0x3F))

    55 	

    56 #define xmlSecIsBase64Char(ch) 		((((ch) >= 'A') && ((ch) <= 'Z')) || \

    57 					 (((ch) >= 'a') && ((ch) <= 'z')) || \

    58 					 (((ch) >= '0') && ((ch) <= '9')) || \

    59 					 ((ch) == '+') || ((ch) == '/')) 

    60 #define xmlSecIsBase64Space(ch)		(((ch) == ' ') || ((ch) == '\t') || \

    61 					 ((ch) == '\x0d') || ((ch) == '\x0a'))

    62 

    63 

    64 

    65 /***********************************************************************

    66  *

    67  * Base64 Context

    68  *

    69  ***********************************************************************/

    70 typedef enum {

    71     xmlSecBase64StatusConsumeAndNext  = 0,

    72     xmlSecBase64StatusConsumeAndRepeat,

    73     xmlSecBase64StatusNext,

    74     xmlSecBase64StatusDone,

    75     xmlSecBase64StatusFailed

    76 } xmlSecBase64Status;

    77 

    78 struct _xmlSecBase64Ctx {

    79     int			encode;    

    80     int                 inByte;

    81     int                 inPos;

    82     xmlSecSize		linePos;

    83     xmlSecSize		columns;  

    84     int                 finished;

    85 };

    86 

    87 static xmlSecBase64Status	xmlSecBase64CtxEncodeByte	(xmlSecBase64CtxPtr ctx, 

    88 								 xmlSecByte  inByte, 

    89 								 xmlSecByte* outByte);

    90 static xmlSecBase64Status	xmlSecBase64CtxEncodeByteFinal	(xmlSecBase64CtxPtr ctx, 

    91 								 xmlSecByte* outByte);

    92 static xmlSecBase64Status	xmlSecBase64CtxDecodeByte	(xmlSecBase64CtxPtr ctx, 

    93 								 xmlSecByte inByte, 

    94 								 xmlSecByte* outByte);

    95 static int			xmlSecBase64CtxEncode		(xmlSecBase64CtxPtr ctx, 

    96                 						 const xmlSecByte* inBuf, 

    97 								 xmlSecSize inBufSize, 

    98 								 xmlSecSize* inBufResSize,

    99                 						 xmlSecByte* outBuf, 

   100 								 xmlSecSize outBufSize, 

   101 								 xmlSecSize* outBufResSize);

   102 static int			xmlSecBase64CtxEncodeFinal	(xmlSecBase64CtxPtr ctx, 

   103                 						 xmlSecByte* outBuf, 

   104 								 xmlSecSize outBufSize, 

   105 								 xmlSecSize* outBufResSize);

   106 static int			xmlSecBase64CtxDecode		(xmlSecBase64CtxPtr ctx, 

   107                 						 const xmlSecByte* inBuf, 

   108 								 xmlSecSize inBufSize, 

   109 								 xmlSecSize* inBufResSize,

   110                 						 xmlSecByte* outBuf, 

   111 								 xmlSecSize outBufSize, 

   112 								 xmlSecSize* outBufResSize);

   113 static int			xmlSecBase64CtxDecodeIsFinished	(xmlSecBase64CtxPtr ctx);

   114 

   115 /**

   116  * xmlSecBase64CtxCreate:

   117  * @encode:		the encode/decode flag (1 - encode, 0 - decode) 

   118  * @columns: 		the max line length.

   119  *

   120  * Allocates and initializes new base64 context.

   121  *

   122  * Returns a pointer to newly created #xmlSecBase64Ctx structure

   123  * or NULL if an error occurs.

   124  */

   125 EXPORT_C

   126 xmlSecBase64CtxPtr	

   127 xmlSecBase64CtxCreate(int encode, int columns) {

   128     xmlSecBase64CtxPtr ctx;

   129     int ret;

   130     

   131     /*

   132      * Allocate a new xmlSecBase64CtxPtr and fill the fields.

   133      */

   134     ctx = (xmlSecBase64CtxPtr) xmlMalloc(sizeof(xmlSecBase64Ctx));    

   135     if (ctx == NULL) {

   136 	xmlSecError(XMLSEC_ERRORS_HERE,

   137 		    NULL,

   138 		    NULL,

   139 		    XMLSEC_ERRORS_R_MALLOC_FAILED,

   140 		    "sizeof(xmlSecBase64Ctx)=%d", 

   141 		    sizeof(xmlSecBase64Ctx));

   142 	return(NULL);

   143     }

   144     

   145     ret = xmlSecBase64CtxInitialize(ctx, encode, columns);

   146     if(ret < 0) {

   147 	xmlSecError(XMLSEC_ERRORS_HERE,

   148 		    NULL,

   149 		    "xmlSecBase64CtxInitialize",

   150 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   151 		    XMLSEC_ERRORS_NO_MESSAGE);

   152 	xmlSecBase64CtxDestroy(ctx);

   153 	return(NULL);

   154     }

   155     return(ctx);

   156 }

   157 

   158 /**

   159  * xmlSecBase64CtxDestroy:

   160  * @ctx: 		the pointer to #xmlSecBase64Ctx structure.

   161  * 

   162  * Destroys base64 context.

   163  */

   164 EXPORT_C

   165 void

   166 xmlSecBase64CtxDestroy(xmlSecBase64CtxPtr ctx) {

   167     xmlSecAssert(ctx != NULL);

   168     

   169     xmlSecBase64CtxFinalize(ctx);

   170     xmlFree(ctx);

   171 }

   172 

   173 /**

   174  * xmlSecBase64CtxInitialize:

   175  * @ctx:		the pointer to #xmlSecBase64Ctx structure,

   176  * @encode:		the encode/decode flag (1 - encode, 0 - decode) 

   177  * @columns: 		the max line length.

   178  *

   179  * Initializes new base64 context.

   180  *

   181  * Returns 0 on success and a negative value otherwise.

   182  */

   183 EXPORT_C

   184 int 

   185 xmlSecBase64CtxInitialize(xmlSecBase64CtxPtr ctx, int encode, int columns) {    

   186     xmlSecAssert2(ctx != NULL, -1);

   187 

   188     memset(ctx, 0, sizeof(xmlSecBase64Ctx));

   189 

   190     ctx->encode     = encode;

   191     ctx->columns    = columns;

   192     return(0);

   193 }

   194 

   195 /**

   196  * xmlSecBase64CtxFinalize:

   197  * @ctx:		the pointer to #xmlSecBase64Ctx structure,

   198  *

   199  * Frees all the resources allocated by @ctx.

   200  */

   201 EXPORT_C

   202 void 

   203 xmlSecBase64CtxFinalize(xmlSecBase64CtxPtr ctx) {    

   204     xmlSecAssert(ctx != NULL);

   205 

   206     memset(ctx, 0, sizeof(xmlSecBase64Ctx)); 

   207 }	

   208 

   209 /**

   210  * xmlSecBase64CtxUpdate:

   211  * @ctx: 		the pointer to #xmlSecBase64Ctx structure

   212  * @in:			the input buffer

   213  * @inSize: 		the input buffer size

   214  * @out: 		the output buffer

   215  * @outSize: 		the output buffer size

   216  *

   217  * Encodes or decodes the next piece of data from input buffer.

   218  * 

   219  * Returns the number of bytes written to output buffer or 

   220  * -1 if an error occurs.

   221  */

   222 EXPORT_C

   223 int

   224 xmlSecBase64CtxUpdate(xmlSecBase64CtxPtr ctx,

   225 		     const xmlSecByte *in, xmlSecSize inSize, 

   226 		     xmlSecByte *out, xmlSecSize outSize) {

   227     xmlSecSize inResSize = 0, outResSize = 0;

   228     int ret;

   229     

   230     xmlSecAssert2(ctx != NULL, -1);

   231     xmlSecAssert2(in != NULL, -1);

   232     xmlSecAssert2(out != NULL, -1);

   233 

   234     if(ctx->encode != 0) {

   235 	ret = xmlSecBase64CtxEncode(ctx, in, inSize, &inResSize, 

   236 				    out, outSize, &outResSize);

   237 	if((ret < 0) || (inResSize != inSize)) {

   238 	    xmlSecError(XMLSEC_ERRORS_HERE, 

   239 			NULL,

   240 			"xmlSecBase64CtxEncode",

   241 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   242 			XMLSEC_ERRORS_NO_MESSAGE);

   243     	    return(-1);

   244 	}

   245     } else {

   246 	ret = xmlSecBase64CtxDecode(ctx, in, inSize, &inResSize, 

   247 				    out, outSize, &outResSize);

   248 	if((ret < 0) || (inResSize != inSize)) {

   249 	    xmlSecError(XMLSEC_ERRORS_HERE, 

   250 			NULL,

   251 			"xmlSecBase64CtxDecode",

   252 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   253 			XMLSEC_ERRORS_NO_MESSAGE);

   254     	    return(-1);

   255 	}

   256     }

   257 

   258     return(outResSize);

   259 }

   260 

   261 /**

   262  * xmlSecBase64CtxFinal:

   263  * @ctx: 		the pointer to #xmlSecBase64Ctx structure

   264  * @out: 		the output buffer

   265  * @outSize: 		the output buffer size

   266  *

   267  * Encodes or decodes the last piece of data stored in the context

   268  * and finalizes the result.

   269  *

   270  * Returns the number of bytes written to output buffer or 

   271  * -1 if an error occurs.

   272  */

   273 EXPORT_C

   274 int

   275 xmlSecBase64CtxFinal(xmlSecBase64CtxPtr ctx, 

   276 		    xmlSecByte *out, xmlSecSize outSize) {

   277     xmlSecSize outResSize = 0;

   278     int ret;

   279         

   280     xmlSecAssert2(ctx != NULL, -1);

   281     xmlSecAssert2(out != NULL, -1);    

   282     xmlSecAssert2(outSize > 0, -1);    

   283 

   284     if(ctx->encode != 0) {    

   285 	ret = xmlSecBase64CtxEncodeFinal(ctx, out, outSize, &outResSize);

   286         if(ret < 0) {

   287 	    xmlSecError(XMLSEC_ERRORS_HERE, 

   288 			NULL,

   289 			"xmlSecBase64CtxEncodeFinal",

   290 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   291 			"outSize=%d", outSize);

   292 	    return(-1);

   293 	}

   294     } else {

   295 	if(!xmlSecBase64CtxDecodeIsFinished(ctx)) {

   296 	    xmlSecError(XMLSEC_ERRORS_HERE, 

   297 			NULL,

   298 			"xmlSecBase64CtxIsFinished",

   299 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   300 			XMLSEC_ERRORS_NO_MESSAGE);

   301     	    return(-1);

   302 	}	

   303     }

   304     

   305     /* add \0 */

   306     if((outResSize + 1) < outSize) {

   307 	out[outResSize] = '\0';

   308     }

   309     return(outResSize);

   310 }

   311 

   312 static xmlSecBase64Status

   313 xmlSecBase64CtxEncodeByte(xmlSecBase64CtxPtr ctx, xmlSecByte inByte, xmlSecByte* outByte) {

   314     xmlSecAssert2(ctx != NULL, xmlSecBase64StatusFailed);

   315     xmlSecAssert2(outByte != NULL, xmlSecBase64StatusFailed);

   316 

   317     if((ctx->columns > 0) && (ctx->linePos >= ctx->columns)) {

   318         (*outByte) = '\n';

   319         ctx->linePos = 0;

   320         return(xmlSecBase64StatusConsumeAndRepeat);

   321     } else if(ctx->inPos == 0) {

   322         /* we just started new block */

   323 	(*outByte) = base64[xmlSecBase64Encode1(inByte)];

   324         ctx->inByte = inByte;

   325         ++ctx->linePos;

   326         ++ctx->inPos;

   327         return(xmlSecBase64StatusConsumeAndNext);

   328     } else if(ctx->inPos == 1) {

   329 	(*outByte) = base64[xmlSecBase64Encode2(ctx->inByte, inByte)];

   330         ctx->inByte = inByte;

   331         ++ctx->linePos;

   332         ++ctx->inPos;

   333         return(xmlSecBase64StatusConsumeAndNext);

   334     } else if(ctx->inPos == 2) {

   335 	(*outByte) = base64[xmlSecBase64Encode3(ctx->inByte, inByte)];

   336         ctx->inByte = inByte;

   337         ++ctx->linePos;

   338         ++ctx->inPos;

   339         return(xmlSecBase64StatusConsumeAndRepeat);

   340     } else if(ctx->inPos == 3) {

   341 	(*outByte) = base64[xmlSecBase64Encode4(ctx->inByte)];

   342         ++ctx->linePos;

   343         ctx->inByte = 0;

   344         ctx->inPos  = 0;

   345         return(xmlSecBase64StatusConsumeAndNext);

   346     }

   347 

   348     xmlSecError(XMLSEC_ERRORS_HERE, 

   349 		NULL,

   350 		NULL,

   351 		XMLSEC_ERRORS_R_INVALID_DATA,

   352 		"ctx->inPos=%d", ctx->inPos);

   353     return(xmlSecBase64StatusFailed);

   354 }

   355 

   356 static xmlSecBase64Status

   357 xmlSecBase64CtxEncodeByteFinal(xmlSecBase64CtxPtr ctx, xmlSecByte* outByte) {

   358     xmlSecAssert2(ctx != NULL, xmlSecBase64StatusFailed);

   359     xmlSecAssert2(outByte != NULL, xmlSecBase64StatusFailed);

   360 

   361     if(ctx->inPos == 0) {

   362         return(xmlSecBase64StatusDone);

   363     } else if((ctx->columns > 0) && (ctx->linePos >= ctx->columns)) {

   364         (*outByte) = '\n';

   365         ctx->linePos = 0;

   366         return(xmlSecBase64StatusConsumeAndRepeat);

   367     } else if(ctx->finished == 0) {

   368         ctx->finished = 1;

   369         return(xmlSecBase64CtxEncodeByte(ctx, 0, outByte));

   370     } else if(ctx->inPos < 3) {

   371         (*outByte) = '=';

   372         ++ctx->inPos;

   373         ++ctx->linePos;

   374         return(xmlSecBase64StatusConsumeAndRepeat);

   375     } else if(ctx->inPos == 3) {

   376         (*outByte) = '=';

   377         ++ctx->linePos;

   378         ctx->inPos = 0;

   379         return(xmlSecBase64StatusConsumeAndRepeat);

   380     }

   381 

   382     xmlSecError(XMLSEC_ERRORS_HERE, 

   383 		NULL,

   384 		NULL,

   385 		XMLSEC_ERRORS_R_INVALID_DATA,

   386 		"ctx->inPos=%d", ctx->inPos);

   387     return(xmlSecBase64StatusFailed);

   388 }

   389 

   390 static xmlSecBase64Status

   391 xmlSecBase64CtxDecodeByte(xmlSecBase64CtxPtr ctx, xmlSecByte inByte, xmlSecByte* outByte) {

   392     xmlSecAssert2(ctx != NULL, xmlSecBase64StatusFailed);

   393     xmlSecAssert2(outByte != NULL, xmlSecBase64StatusFailed);    

   394 

   395     if((ctx->finished != 0) && (ctx->inPos == 0)) {

   396         return(xmlSecBase64StatusDone);

   397     } if(inByte == '=') {

   398         ctx->finished = 1;

   399         if(ctx->inPos < 2) {

   400 	    xmlSecError(XMLSEC_ERRORS_HERE, 

   401 			NULL,

   402 			NULL,

   403 			XMLSEC_ERRORS_R_INVALID_DATA,

   404 			"ctx->inPos=%d", ctx->inPos);

   405             return(xmlSecBase64StatusFailed);

   406         } else if(ctx->inPos == 2) {

   407             ++ctx->inPos;

   408             return(xmlSecBase64StatusNext);            

   409         } else if(ctx->inPos == 3) {

   410             ctx->inPos = 0;

   411             return(xmlSecBase64StatusNext);

   412         } else {

   413 	    xmlSecError(XMLSEC_ERRORS_HERE, 

   414 			NULL,

   415 			NULL,

   416 			XMLSEC_ERRORS_R_INVALID_DATA,

   417 			"ctx->inPos=%d", ctx->inPos);

   418             return(xmlSecBase64StatusFailed);

   419         }

   420     } else if(xmlSecIsBase64Space(inByte)) {

   421         return(xmlSecBase64StatusNext);

   422     } else if(!xmlSecIsBase64Char(inByte) || (ctx->finished != 0)) {

   423 	xmlSecError(XMLSEC_ERRORS_HERE, 

   424 		    NULL,

   425 		    NULL,

   426 		    XMLSEC_ERRORS_R_INVALID_DATA,

   427 		    "inByte=0x%02x", inByte);

   428         return(xmlSecBase64StatusFailed);

   429     }

   430 

   431     /* convert from character to position in base64 array */

   432     if((inByte >= 'A') && (inByte <= 'Z')) {

   433 	inByte = (inByte - 'A');

   434     } else if((inByte >= 'a') && (inByte <= 'z')) {

   435 	inByte = 26 + (inByte - 'a');

   436     } else if((inByte >= '0') && (inByte <= '9')) {

   437 	inByte = 52 + (inByte - '0'); 

   438     } else if(inByte == '+') {

   439     	inByte = 62;

   440     } else if(inByte == '/') {

   441 	inByte = 63;

   442     }

   443         

   444     if(ctx->inPos == 0) {

   445         ctx->inByte = inByte;

   446         ++ctx->inPos;

   447         return(xmlSecBase64StatusNext);

   448     } else if(ctx->inPos == 1) {

   449         (*outByte) = xmlSecBase64Decode1(ctx->inByte, inByte);

   450         ctx->inByte = inByte;

   451         ++ctx->inPos;

   452         return(xmlSecBase64StatusConsumeAndNext);

   453     } else if(ctx->inPos == 2) {

   454         (*outByte) = xmlSecBase64Decode2(ctx->inByte, inByte);

   455         ctx->inByte = inByte;

   456         ++ctx->inPos;

   457         return(xmlSecBase64StatusConsumeAndNext);

   458     } else if(ctx->inPos == 3) {

   459         (*outByte) = xmlSecBase64Decode3(ctx->inByte, inByte);

   460         ctx->inByte = 0;

   461         ctx->inPos = 0;

   462         return(xmlSecBase64StatusConsumeAndNext);

   463     }

   464 

   465     xmlSecError(XMLSEC_ERRORS_HERE, 

   466 		NULL,

   467 		NULL,

   468 		XMLSEC_ERRORS_R_INVALID_DATA,

   469 		"ctx->inPos=%d", ctx->inPos);

   470     return(xmlSecBase64StatusFailed);

   471 }

   472 

   473 

   474 static int

   475 xmlSecBase64CtxEncode(xmlSecBase64CtxPtr ctx, 

   476                      const xmlSecByte* inBuf, xmlSecSize inBufSize, xmlSecSize* inBufResSize,

   477                      xmlSecByte* outBuf, xmlSecSize outBufSize, xmlSecSize* outBufResSize) {

   478     xmlSecBase64Status status = xmlSecBase64StatusNext;

   479     xmlSecSize inPos, outPos;

   480     

   481     xmlSecAssert2(ctx != NULL, -1);

   482     xmlSecAssert2(inBuf != NULL, -1);

   483     xmlSecAssert2(inBufResSize != NULL, -1);

   484     xmlSecAssert2(outBuf != NULL, -1);

   485     xmlSecAssert2(outBufResSize != NULL, -1);

   486 

   487     /* encode */

   488     for(inPos = outPos = 0; (inPos < inBufSize) && (outPos < outBufSize); ) {

   489         status = xmlSecBase64CtxEncodeByte(ctx, inBuf[inPos], &(outBuf[outPos]));

   490         switch(status) {

   491             case xmlSecBase64StatusConsumeAndNext:

   492                 ++inPos;

   493                 ++outPos;

   494                 break;

   495             case xmlSecBase64StatusConsumeAndRepeat:

   496                 ++outPos;

   497                 break;

   498             case xmlSecBase64StatusNext:

   499             case xmlSecBase64StatusDone:

   500             case xmlSecBase64StatusFailed:

   501 		xmlSecError(XMLSEC_ERRORS_HERE, 

   502 			    NULL,

   503 			    "xmlSecBase64CtxEncodeByte",

   504 			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   505 			    "status=%d", status);

   506                 return(-1);

   507         }

   508     }

   509 

   510     (*inBufResSize)  = inPos;

   511     (*outBufResSize) = outPos;

   512 

   513     return(0);

   514 }

   515 

   516 static int

   517 xmlSecBase64CtxEncodeFinal(xmlSecBase64CtxPtr ctx, 

   518                      xmlSecByte* outBuf, xmlSecSize outBufSize, xmlSecSize* outBufResSize) {

   519     xmlSecBase64Status status = xmlSecBase64StatusNext;

   520     xmlSecSize outPos;

   521     

   522     xmlSecAssert2(ctx != NULL, -1);

   523     xmlSecAssert2(outBuf != NULL, -1);

   524     xmlSecAssert2(outBufResSize != NULL, -1);

   525 

   526     /* encode final bytes */

   527     for(outPos = 0; (outPos < outBufSize) && (status != xmlSecBase64StatusDone); ) {

   528         status = xmlSecBase64CtxEncodeByteFinal(ctx, &(outBuf[outPos]));

   529         switch(status) {

   530             case xmlSecBase64StatusConsumeAndNext:

   531             case xmlSecBase64StatusConsumeAndRepeat:

   532                 ++outPos;

   533                 break;

   534             case xmlSecBase64StatusDone:

   535                 break;

   536             case xmlSecBase64StatusNext:

   537             case xmlSecBase64StatusFailed:

   538 		xmlSecError(XMLSEC_ERRORS_HERE, 

   539 			    NULL,

   540 			    "xmlSecBase64CtxEncodeByteFinal",

   541 			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   542 			    "status=%d", status);

   543                 return(-1);

   544         }

   545     }

   546 

   547     if(status != xmlSecBase64StatusDone) {

   548 	xmlSecError(XMLSEC_ERRORS_HERE, 

   549 		    NULL,

   550 		    NULL,

   551 		    XMLSEC_ERRORS_R_INVALID_SIZE,

   552 		    "outBufSize=%d", outBufSize);

   553         return(-1);

   554     }

   555     if(outPos < outBufSize) {

   556         outBuf[outPos] = '\0'; /* just in case */

   557     }

   558 

   559     (*outBufResSize) = outPos;

   560     return(0);

   561 }

   562 

   563 

   564 static int

   565 xmlSecBase64CtxDecode(xmlSecBase64CtxPtr ctx, 

   566                      const xmlSecByte* inBuf, xmlSecSize inBufSize, xmlSecSize* inBufResSize,

   567                      xmlSecByte* outBuf, xmlSecSize outBufSize, xmlSecSize* outBufResSize) {

   568     xmlSecBase64Status status = xmlSecBase64StatusNext;

   569     xmlSecSize inPos, outPos;

   570     

   571     xmlSecAssert2(ctx != NULL, -1);

   572     xmlSecAssert2(inBuf != NULL, -1);

   573     xmlSecAssert2(inBufResSize != NULL, -1);

   574     xmlSecAssert2(outBuf != NULL, -1);

   575     xmlSecAssert2(outBufResSize != NULL, -1);

   576 

   577     /* decode */

   578     for(inPos = outPos = 0; (inPos < inBufSize) && (outPos < outBufSize) && (status != xmlSecBase64StatusDone); ) {

   579         status = xmlSecBase64CtxDecodeByte(ctx, inBuf[inPos], &(outBuf[outPos]));

   580         switch(status) {

   581             case xmlSecBase64StatusConsumeAndNext:

   582                 ++inPos;

   583                 ++outPos;

   584                 break;

   585             case xmlSecBase64StatusConsumeAndRepeat:

   586                 ++outPos;

   587                 break;

   588             case xmlSecBase64StatusNext:

   589                 ++inPos;

   590                 break;

   591             case xmlSecBase64StatusDone:

   592                 break;

   593             case xmlSecBase64StatusFailed:

   594 		xmlSecError(XMLSEC_ERRORS_HERE, 

   595 			    NULL,

   596 			    "xmlSecBase64CtxDecodeByte",

   597 			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   598 			    "status=%d", status);

   599                 return(-1);

   600         }

   601     }

   602 

   603     /* skip spaces at the end */

   604     while((inPos < inBufSize) && xmlSecIsBase64Space(inBuf[inPos])) {

   605         ++inPos;

   606     }

   607 

   608     (*inBufResSize)  = inPos;

   609     (*outBufResSize) = outPos;

   610 

   611     return(0);

   612 }

   613 

   614 static int

   615 xmlSecBase64CtxDecodeIsFinished(xmlSecBase64CtxPtr ctx) {

   616     xmlSecAssert2(ctx != NULL, -1);

   617 

   618     return((ctx->inPos == 0) ? 1 : 0);

   619 }

   620 

   621 /**

   622  * xmlSecBase64Encode:

   623  * @buf: 		the input buffer.

   624  * @len: 		the input buffer size.

   625  * @columns: 		the output max line length (if 0 then no line breaks

   626  *          		would be inserted)

   627  *

   628  * Encodes the data from input buffer and allocates the string for the result.

   629  * The caller is responsible for freeing returned buffer using

   630  * xmlFree() function.

   631  *

   632  * Returns newly allocated string with base64 encoded data 

   633  * or NULL if an error occurs.

   634  */

   635 EXPORT_C

   636 xmlChar*

   637 xmlSecBase64Encode(const xmlSecByte *buf, xmlSecSize len, int columns) {

   638     xmlSecBase64Ctx ctx;

   639     xmlChar *ptr;

   640     xmlSecSize size;    

   641     int size_update, size_final;

   642     int ret;

   643 

   644     xmlSecAssert2(buf != NULL, NULL);

   645 

   646     ret = xmlSecBase64CtxInitialize(&ctx, 1, columns);

   647     if(ret < 0) {

   648 	xmlSecError(XMLSEC_ERRORS_HERE,

   649 		    NULL,

   650 		    "xmlSecBase64CtxInitialize",

   651 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   652 		    XMLSEC_ERRORS_NO_MESSAGE);

   653 	return(NULL);

   654     }

   655     

   656     /* create result buffer */

   657     size = (4 * len) / 3 + 4;

   658     if(columns > 0) {

   659 	size += (size / columns) + 4;

   660     }

   661     ptr = (xmlChar*) xmlMalloc(size);

   662     if(ptr == NULL) {

   663 	xmlSecError(XMLSEC_ERRORS_HERE,

   664 		    NULL,

   665 		    NULL,

   666 		    XMLSEC_ERRORS_R_MALLOC_FAILED,

   667 		    "size=%d", size);

   668 	xmlSecBase64CtxFinalize(&ctx);

   669 	return(NULL);

   670     }

   671 

   672     ret = xmlSecBase64CtxUpdate(&ctx, buf, len, (xmlSecByte*)ptr, size);

   673     if(ret < 0) {

   674 	xmlSecError(XMLSEC_ERRORS_HERE,

   675 		    NULL,

   676 		    "xmlSecBase64CtxUpdate",

   677 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   678 		    "len=%d", len);

   679 	xmlFree(ptr);

   680 	xmlSecBase64CtxFinalize(&ctx);

   681 	return(NULL);

   682     }

   683     size_update = ret;

   684 

   685     ret = xmlSecBase64CtxFinal(&ctx, ((xmlSecByte*)ptr) + size_update, size - size_update);

   686     if(ret < 0) {

   687 	xmlSecError(XMLSEC_ERRORS_HERE,

   688 		    NULL,

   689 		    "xmlSecBase64CtxFinal",

   690 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   691 		    XMLSEC_ERRORS_NO_MESSAGE);

   692 	xmlFree(ptr);

   693 	xmlSecBase64CtxFinalize(&ctx);

   694 	return(NULL);

   695     }

   696     size_final = ret;

   697     ptr[size_update + size_final] = '\0';

   698     

   699     xmlSecBase64CtxFinalize(&ctx);

   700     return(ptr);

   701 }

   702 

   703 /**

   704  * xmlSecBase64Decode:

   705  * @str: 		the input buffer with base64 encoded string

   706  * @buf: 		the output buffer

   707  * @len: 		the output buffer size

   708  *

   709  * Decodes input base64 encoded string and puts result into

   710  * the output buffer.

   711  *

   712  * Returns the number of bytes written to the output buffer or 

   713  * a negative value if an error occurs 

   714  */

   715 EXPORT_C

   716 int

   717 xmlSecBase64Decode(const xmlChar* str, xmlSecByte *buf, xmlSecSize len) {

   718     xmlSecBase64Ctx ctx;

   719     int size_update;

   720     int size_final;

   721     int ret;

   722 

   723     xmlSecAssert2(str != NULL, -1);

   724     xmlSecAssert2(buf != NULL, -1);

   725 

   726     ret = xmlSecBase64CtxInitialize(&ctx, 0, 0);

   727     if(ret < 0) {

   728 	xmlSecError(XMLSEC_ERRORS_HERE,

   729 		    NULL,

   730 		    "xmlSecBase64CtxInitialize",

   731 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   732 		    XMLSEC_ERRORS_NO_MESSAGE);

   733 	return(-1);

   734     }

   735     

   736     ret = xmlSecBase64CtxUpdate(&ctx, (const xmlSecByte*)str, xmlStrlen(str), buf, len);

   737     if(ret < 0) {

   738 	xmlSecError(XMLSEC_ERRORS_HERE,

   739 		    NULL,

   740 		    "xmlSecBase64CtxUpdate",

   741 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   742 		    XMLSEC_ERRORS_NO_MESSAGE);

   743 	xmlSecBase64CtxFinalize(&ctx);

   744 	return(-1);

   745     }

   746 

   747     size_update = ret;

   748     ret = xmlSecBase64CtxFinal(&ctx, buf + size_update, len - size_update);

   749     if(ret < 0) {

   750 	xmlSecError(XMLSEC_ERRORS_HERE,

   751 		    NULL,

   752 		    "xmlSecBase64CtxFinal",

   753 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   754 		    XMLSEC_ERRORS_NO_MESSAGE);

   755 	xmlSecBase64CtxFinalize(&ctx);

   756 	return(-1);

   757     }

   758     size_final = ret;    

   759 

   760     xmlSecBase64CtxFinalize(&ctx);

   761     return(size_update + size_final);

   762 }

   763 

   764 /**************************************************************

   765  *

   766  * Base64 Transform

   767  *

   768  * xmlSecBase64Ctx is located after xmlSecTransform

   769  * 

   770  **************************************************************/

   771 #define xmlSecBase64Size \

   772 	(sizeof(xmlSecTransform) + sizeof(xmlSecBase64Ctx))

   773 #define xmlSecBase64GetCtx(transform) \

   774     ((xmlSecTransformCheckSize((transform), xmlSecBase64Size)) ? \

   775 	(xmlSecBase64CtxPtr)(((xmlSecByte*)(transform)) + sizeof(xmlSecTransform)) : \

   776 	(xmlSecBase64CtxPtr)NULL)

   777 

   778 static int		xmlSecBase64Initialize		(xmlSecTransformPtr transform);

   779 static void		xmlSecBase64Finalize		(xmlSecTransformPtr transform);

   780 static int 		xmlSecBase64Execute		(xmlSecTransformPtr transform, 

   781 							 int last, 

   782 							 xmlSecTransformCtxPtr transformCtx);

   783 

   784 static xmlSecTransformKlass xmlSecBase64Klass = {

   785     /* klass/object sizes */

   786     sizeof(xmlSecTransformKlass),		/* xmlSecSize klassSize */

   787     xmlSecBase64Size,				/* xmlSecSize objSize */

   788 

   789     xmlSecNameBase64,				/* const xmlChar* name; */

   790     xmlSecHrefBase64,				/* const xmlChar* href; */

   791     xmlSecTransformUsageDSigTransform,		/* xmlSecAlgorithmUsage usage; */

   792 

   793     xmlSecBase64Initialize, 			/* xmlSecTransformInitializeMethod initialize; */

   794     xmlSecBase64Finalize,			/* xmlSecTransformFinalizeMethod finalize; */

   795     NULL,					/* xmlSecTransformNodeReadMethod readNode; */

   796     NULL,					/* xmlSecTransformNodeWriteMethod writeNode; */

   797     NULL,					/* xmlSecTransformSetKeyReqMethod setKeyReq; */

   798     NULL,					/* xmlSecTransformSetKeyMethod setKey; */

   799     NULL,					/* xmlSecTransformValidateMethod validate; */

   800     xmlSecTransformDefaultGetDataType,		/* xmlSecTransformGetDataTypeMethod getDataType; */

   801     xmlSecTransformDefaultPushBin,		/* xmlSecTransformPushBinMethod pushBin; */

   802     xmlSecTransformDefaultPopBin,		/* xmlSecTransformPopBinMethod popBin; */

   803     NULL,					/* xmlSecTransformPushXmlMethod pushXml; */

   804     NULL,					/* xmlSecTransformPopXmlMethod popXml; */

   805     xmlSecBase64Execute,			/* xmlSecTransformExecuteMethod execute; */

   806 

   807     NULL,					/* void* reserved0; */

   808     NULL,					/* void* reserved1; */

   809 };

   810 

   811 /**

   812  * xmlSecTransformBase64GetKlass:

   813  *

   814  * The Base64 transform klass (http://www.w3.org/TR/xmldsig-core/#sec-Base-64).

   815  * The normative specification for base64 decoding transforms is RFC 2045

   816  * (http://www.ietf.org/rfc/rfc2045.txt). The base64 Transform element has 

   817  * no content. The input is decoded by the algorithms. This transform is 

   818  * useful if an application needs to sign the raw data associated with 

   819  * the encoded content of an element.

   820  *

   821  * Returns base64 transform id.

   822  */

   823 EXPORT_C

   824 xmlSecTransformId 

   825 xmlSecTransformBase64GetKlass(void) {

   826     return(&xmlSecBase64Klass);

   827 }

   828 

   829 /**

   830  * xmlSecTransformBase64SetLineSize:

   831  * @transform: 		the pointer to BASE64 encode transform.

   832  * @lineSize: 		the new max line size.

   833  *

   834  * Sets the max line size to @lineSize.

   835  */

   836 EXPORT_C

   837 void

   838 xmlSecTransformBase64SetLineSize(xmlSecTransformPtr transform, xmlSecSize lineSize) {

   839     xmlSecBase64CtxPtr ctx;

   840     

   841     xmlSecAssert(xmlSecTransformCheckId(transform, xmlSecTransformBase64Id));

   842     

   843     ctx = xmlSecBase64GetCtx(transform);

   844     xmlSecAssert(ctx != NULL);

   845     

   846     ctx->columns = lineSize;    

   847 }

   848 

   849 static int

   850 xmlSecBase64Initialize(xmlSecTransformPtr transform) {

   851     xmlSecBase64CtxPtr ctx;

   852     int ret;

   853     

   854     xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecTransformBase64Id), -1);

   855 

   856     ctx = xmlSecBase64GetCtx(transform);

   857     xmlSecAssert2(ctx != NULL, -1);

   858 

   859     transform->operation = xmlSecTransformOperationDecode;

   860     ret = xmlSecBase64CtxInitialize(ctx, 0, XMLSEC_BASE64_LINESIZE);

   861     if(ret < 0) {

   862 	xmlSecError(XMLSEC_ERRORS_HERE,

   863 		    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   864 		    "xmlSecBase64CtxInitialize",

   865 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   866 		    XMLSEC_ERRORS_NO_MESSAGE);

   867 	return(-1);

   868     }

   869     

   870     return(0);

   871 }

   872 

   873 static void

   874 xmlSecBase64Finalize(xmlSecTransformPtr transform) {

   875     xmlSecBase64CtxPtr ctx;

   876     

   877     xmlSecAssert(xmlSecTransformCheckId(transform, xmlSecTransformBase64Id));

   878 

   879     ctx = xmlSecBase64GetCtx(transform);

   880     xmlSecAssert(ctx != NULL);

   881     

   882     xmlSecBase64CtxFinalize(ctx);

   883 }

   884 

   885 static int 

   886 xmlSecBase64Execute(xmlSecTransformPtr transform, int last, xmlSecTransformCtxPtr transformCtx) {

   887     xmlSecBase64CtxPtr ctx;

   888     xmlSecBufferPtr in, out;

   889     xmlSecSize inSize, outSize, outLen;

   890     int ret;

   891 

   892     xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecTransformBase64Id), -1);

   893     xmlSecAssert2((transform->operation == xmlSecTransformOperationEncode) || (transform->operation == xmlSecTransformOperationDecode), -1);

   894     xmlSecAssert2(transformCtx != NULL, -1);

   895     

   896     ctx = xmlSecBase64GetCtx(transform);

   897     xmlSecAssert2(ctx != NULL, -1);

   898     

   899     in = &(transform->inBuf);

   900     out = &(transform->outBuf);

   901 

   902     if(transform->status == xmlSecTransformStatusNone) {

   903 	ctx->encode = (transform->operation == xmlSecTransformOperationEncode) ? 1 : 0;

   904 	transform->status = xmlSecTransformStatusWorking;

   905     }

   906 

   907     switch(transform->status) {

   908 	case xmlSecTransformStatusWorking:

   909 	    inSize = xmlSecBufferGetSize(in);

   910 	    outSize = xmlSecBufferGetSize(out);

   911 	    if(inSize > 0) {

   912 		if(ctx->encode != 0) {

   913 		    outLen = 4 * inSize / 3 + 8;

   914 		    if(ctx->columns > 0) {

   915 			outLen += inSize / ctx->columns + 4;

   916 		    }

   917 		} else {

   918 		    outLen = 3 * inSize / 4 + 8;

   919 		}

   920 		ret = xmlSecBufferSetMaxSize(out, outSize + outLen);

   921 		if(ret < 0) {

   922 		    xmlSecError(XMLSEC_ERRORS_HERE, 

   923 				xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   924 				"xmlSecBufferSetMaxSize",

   925 				XMLSEC_ERRORS_R_XMLSEC_FAILED,

   926 				"size=%d", outSize + outLen);

   927 		    return(-1);

   928 		}

   929 

   930 		/* encode/decode the next chunk */

   931 		ret = xmlSecBase64CtxUpdate(ctx, xmlSecBufferGetData(in), inSize,

   932 					    xmlSecBufferGetData(out) + outSize, 

   933 					    outLen);

   934 		if(ret < 0) {

   935 		    xmlSecError(XMLSEC_ERRORS_HERE, 

   936 				xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   937 				"xmlSecBase64CtxUpdate",

   938 				XMLSEC_ERRORS_R_XMLSEC_FAILED,

   939 				XMLSEC_ERRORS_NO_MESSAGE);

   940 		    return(-1);

   941 		}

   942 		outLen = ret;

   943 		

   944 		/* set correct size */

   945 		ret = xmlSecBufferSetSize(out, outSize + outLen);

   946 		if(ret < 0) {

   947 		    xmlSecError(XMLSEC_ERRORS_HERE, 

   948 				xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   949 				"xmlSecBufferSetSize",

   950 				XMLSEC_ERRORS_R_XMLSEC_FAILED,

   951 				"size=%d", outSize + outLen);

   952 		    return(-1);

   953 		}

   954 		

   955 		/* remove chunk from input */

   956 		ret = xmlSecBufferRemoveHead(in, inSize);

   957 		if(ret < 0) {

   958 		    xmlSecError(XMLSEC_ERRORS_HERE, 

   959 				xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   960 				"xmlSecBufferRemoveHead",

   961 				XMLSEC_ERRORS_R_XMLSEC_FAILED,

   962 				"size=%d", inSize);

   963 		    return(-1);

   964 		}

   965 	    }

   966 	    

   967 	    if(last) {

   968 	        outSize = xmlSecBufferGetSize(out);

   969 

   970 		ret = xmlSecBufferSetMaxSize(out, outSize + 16);

   971 		if(ret < 0) {

   972 		    xmlSecError(XMLSEC_ERRORS_HERE, 

   973 				xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   974 				"xmlSecBufferSetMaxSize",

   975 				XMLSEC_ERRORS_R_XMLSEC_FAILED,

   976 				"size=%d", outSize + 16);

   977 		    return(-1);

   978 		}

   979 	

   980 		/* add from ctx buffer */

   981 		ret = xmlSecBase64CtxFinal(ctx, xmlSecBufferGetData(out) + outSize, 16);

   982 		if(ret < 0) {

   983 		    xmlSecError(XMLSEC_ERRORS_HERE, 

   984 				xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   985 				"xmlSecBase64CtxFinal",

   986 				XMLSEC_ERRORS_R_XMLSEC_FAILED,

   987 				XMLSEC_ERRORS_NO_MESSAGE);

   988 		    return(-1);

   989 		}

   990 		outLen = ret;

   991 		

   992 		/* set correct size */

   993 		ret = xmlSecBufferSetSize(out, outSize + outLen);

   994 		if(ret < 0) {

   995 		    xmlSecError(XMLSEC_ERRORS_HERE, 

   996 				xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   997 				"xmlSecBufferSetSize",

   998 				XMLSEC_ERRORS_R_XMLSEC_FAILED,

   999 				"size=%d", outSize + outLen);

  1000 		    return(-1);

  1001 		}

  1002 		transform->status = xmlSecTransformStatusFinished;

  1003 	    }

  1004 	    break;

  1005 	case xmlSecTransformStatusFinished:

  1006 	    /* the only way we can get here is if there is no input */

  1007 	    xmlSecAssert2(xmlSecBufferGetSize(in) == 0, -1);

  1008 	    break;

  1009 	default:

  1010 	    xmlSecError(XMLSEC_ERRORS_HERE, 

  1011 			xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

  1012 			NULL,

  1013 			XMLSEC_ERRORS_R_INVALID_STATUS,

  1014 			"status=%d", transform->status);

  1015 	    return(-1);

  1016     }

  1017     return(0);

  1018 }

  1019 

  1020