• R/O
  • HTTP
  • SSH
  • HTTPS

openpts: 提交

Repo for OpenPTS version 0.2.X


Commit MetaInfo

修订版e8e5d21da5e7993fab22b5046459abcda2df5c97 (tree)
时间2011-08-19 16:31:39
作者Seiji Munetoh <munetoh@jp.i...>
CommiterSeiji Munetoh

Log Message

fixed issue reported by SAT, base64 functions are updated

更改概述

差异

--- a/include/openpts.h
+++ b/include/openpts.h
@@ -761,11 +761,8 @@ UINT32 freadUint32(FILE * stream, int endian);
761761 OPENPTS_PCR_EVENT_WRAPPER * newEventWrapper();
762762
763763 /* base64.c */
764-int base64size(int len);
765-int encodeBase64(unsigned char *out, unsigned char * in, int len);
766-int decodeBase64(unsigned char *out, unsigned char * in, int len);
767-int decodeBase64core(unsigned char *out, unsigned char * in, int len);
768-
764+char *encodeBase64(unsigned char * in, int inlen, int *outlen);
765+unsigned char *decodeBase64(char * in, int inlen, int *outlen);
769766
770767 /* fsm.c */
771768 // TODO refectoring
--- a/src/action.c
+++ b/src/action.c
@@ -198,29 +198,32 @@ int addBIOSSpecificProperty(OPENPTS_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *eve
198198 switch (event_id) {
199199 case 0x0001:
200200 {
201- char *b64;
202- int len;
201+ char *buf;
202+ int buf_len;
203+
203204 /* SMBIOS */
204205 // bios.smbios=base64()
205206 ctx->conf->smbios_length = event_length;
206207 ctx->conf->smbios = &event->rgbEvent[8];
207208
208209 /* base64 */
209- b64 = malloc(base64size(ctx->conf->smbios_length));
210- // TODO check null
211- len = encodeBase64(
212- (unsigned char *)b64,
210+ buf = encodeBase64(
211+ //(unsigned char *)b64,
213212 (unsigned char *)ctx->conf->smbios,
214- ctx->conf->smbios_length);
215-
216- if (len > BUF_SIZE) {
217- ERROR("SMBIOS size = %d\n", len); // Thinkpad X200 => 3324
213+ ctx->conf->smbios_length,
214+ &buf_len);
215+ if (buf == NULL) {
216+ ERROR("encodeBase64 fail");
217+ return PTS_FATAL;
218+ }
219+ if (buf_len > BUF_SIZE) {
220+ ERROR("SMBIOS size = %d\n", buf_len); // Thinkpad X200 => 3324
218221 updateProperty(ctx, "bios.smbios", "too big");
219222 } else {
220- updateProperty(ctx, "bios.smbios", b64);
223+ updateProperty(ctx, "bios.smbios", buf);
221224 }
222225 // rc = 0;
223- free(b64);
226+ free(buf);
224227 }
225228 break;
226229 default:
@@ -306,8 +309,8 @@ int validateEltoritoBootImage(OPENPTS_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *e
306309 */
307310 int setModuleProperty(OPENPTS_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *eventWrapper) {
308311 TSS_PCR_EVENT *event;
309- char b64digest[SHA1_BASE64_DIGEST_SIZE + 1];
310312 char *buf;
313+ int buf_len;
311314
312315 // DEBUG("setModuleProperty - NA\n");
313316
@@ -325,10 +328,16 @@ int setModuleProperty(OPENPTS_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *eventWrap
325328 }
326329
327330 /* kernel.initrd.digest = PCR => B64 digest */
328- encodeBase64((unsigned char *)b64digest, (unsigned char *)event->rgbPcrValue, SHA1_DIGEST_SIZE);
329- b64digest[SHA1_BASE64_DIGEST_SIZE] = 0;
330-
331- updateProperty(ctx, "kernel.initrd.digest", b64digest);
331+ buf = encodeBase64(
332+ (unsigned char *)event->rgbPcrValue,
333+ SHA1_DIGEST_SIZE,
334+ &buf_len);
335+ if (buf == NULL) {
336+ ERROR("encodeBase64 fail");
337+ return PTS_INTERNAL_ERROR;
338+ }
339+ updateProperty(ctx, "kernel.initrd.digest", buf);
340+ free(buf);
332341
333342 // updateProperty(ctx, "kernel.initrd.filename", (char*)event->rgbEvent);
334343 /* add \n */
@@ -625,7 +634,6 @@ int validateImaMeasurement(OPENPTS_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *even
625634 #ifdef CONFIG_AIDE
626635 TSS_PCR_EVENT *event;
627636 #endif
628- // char b64digest[SHA1_BASE64_DIGEST_SIZE+1];
629637
630638 DEBUG_CAL("validateImaMeasurement - start\n");
631639
@@ -646,7 +654,8 @@ int validateImaMeasurement(OPENPTS_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *even
646654 if (ctx->conf->ima_validation_mode == OPENPTS_VALIDATION_MODE_AIDE) {
647655 int rc = 0;
648656 char *name;
649- char b64digest[SHA1_BASE64_DIGEST_SIZE+1];
657+ char *buf;
658+ int buf_len;
650659
651660 rc = checkEventByAide(ctx->aide_ctx, eventWrapper);
652661
@@ -665,9 +674,16 @@ int validateImaMeasurement(OPENPTS_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *even
665674 #ifdef CONFIG_SQLITE
666675 // TODO no md,
667676 #else
668- encodeBase64((unsigned char *)b64digest, (unsigned char *)md->sha1, SHA1_DIGEST_SIZE);
669- b64digest[SHA1_BASE64_DIGEST_SIZE] = 0;
670- updateImaProperty(ctx, md->name, b64digest, "valid");
677+ buf = encodeBase64(
678+ (unsigned char *)md->sha1,
679+ SHA1_DIGEST_SIZE,
680+ &buf_len);
681+ if (buf == NULL) {
682+ ERROR("encodeBase64 fail");
683+ return PTS_INTERNAL_ERROR;
684+ }
685+ updateImaProperty(ctx, md->name, buf, "valid");
686+ free(buf);
671687 #endif
672688 eventWrapper->status = OPENPTS_RESULT_VALID;
673689 free(name);
@@ -682,10 +698,18 @@ int validateImaMeasurement(OPENPTS_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *even
682698 // DEBUG("validateImaMeasurement w/ AIDE - MISS name=[%s]\n", name);
683699 // updateProperty(ctx, buf, "invalid");
684700 ctx->ima_unknown++;
685- encodeBase64((unsigned char *)b64digest, (unsigned char *)event->rgbEvent, SHA1_DIGEST_SIZE);
686- b64digest[SHA1_BASE64_DIGEST_SIZE] = 0;
687- updateImaProperty(ctx, name, b64digest, "unknown"); // action.c
701+ buf = encodeBase64(
702+ (unsigned char *)event->rgbEvent,
703+ SHA1_DIGEST_SIZE,
704+ &buf_len);
705+ if (buf == NULL) {
706+ ERROR("encodeBase64 fail");
707+ return PTS_INTERNAL_ERROR;
708+ }
709+ updateImaProperty(ctx, name, buf, "unknown"); // action.c
688710 eventWrapper->status = OPENPTS_RESULT_UNKNOWN;
711+ free(buf);
712+
689713 /* add to */
690714 {
691715 char *hex;
@@ -846,15 +870,29 @@ int startCollector(OPENPTS_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *eventWrapper
846870 /* Error */
847871 // printout the example IR data to create the test case
848872 {
849- unsigned char b64[256];
873+ char *buf;
874+ int buf_len;
850875
851876 if (start == NULL) {
852877 start = malloc(sizeof(OPENPTS_EVENT_COLLECTOR_START));
878+ if (start == NULL) {
879+ ERROR("no memory");
880+ return PTS_INTERNAL_ERROR;
881+ }
853882 }
854883 printHex("OPENPTS_EVENT_COLLECTOR_START",
855884 (unsigned char*)start, sizeof(OPENPTS_EVENT_COLLECTOR_START), "\n");
856- encodeBase64(b64, (unsigned char *)start, sizeof(OPENPTS_EVENT_COLLECTOR_START));
857- ERROR("EventData: %s\n", b64);
885+ buf = encodeBase64(
886+ (unsigned char *)start,
887+ sizeof(OPENPTS_EVENT_COLLECTOR_START),
888+ &buf_len);
889+ if (buf == NULL) {
890+ ERROR("encodeBase64 fail");
891+ rc = PTS_INTERNAL_ERROR;
892+ goto free;
893+ }
894+ ERROR("EventData: %s\n", buf);
895+ free(buf);
858896
859897 memcpy(&start->pts_version, &ctx->target_conf->pts_version, 4);
860898 memcpy(&start->collector_uuid, ctx->target_conf->uuid->uuid, 16);
@@ -862,8 +900,18 @@ int startCollector(OPENPTS_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *eventWrapper
862900
863901 printHex("OPENPTS_EVENT_COLLECTOR_START",
864902 (unsigned char*)start, sizeof(OPENPTS_EVENT_COLLECTOR_START), "\n");
865- encodeBase64(b64, (unsigned char *)start, sizeof(OPENPTS_EVENT_COLLECTOR_START));
866- ERROR("EventData: %s\n", b64);
903+ buf = encodeBase64(
904+ (unsigned char *)start,
905+ sizeof(OPENPTS_EVENT_COLLECTOR_START),
906+ &buf_len);
907+ if (buf == NULL) {
908+ ERROR("encodeBase64 fail");
909+ rc = PTS_INTERNAL_ERROR;
910+ goto free;
911+ }
912+ ERROR("EventData: %s\n", buf);
913+ free(buf);
914+ free:
867915 free(start);
868916 }
869917
--- a/src/aide.c
+++ b/src/aide.c
@@ -459,11 +459,14 @@ int loadAideDatabaseFile(AIDE_CONTEXT *ctx, char *filename) {
459459 case AIDE_ITEM_SHA1: // base64
460460 if (!is_null) {
461461 sha1_b64_ptr = ptr;
462- md->sha1 = malloc(SHA1_DIGEST_SIZE + 8);
463- len = decodeBase64(
464- md->sha1,
465- (unsigned char *)ptr,
466- SHA1_BASE64_DIGEST_SIZE);
462+ md->sha1 = decodeBase64(
463+ (char *)ptr,
464+ SHA1_BASE64_DIGEST_SIZE,
465+ &len);
466+ if (md->sha1 == NULL) {
467+ ERROR("decodeBase64 fail");
468+ goto close;
469+ }
467470 if (len != SHA1_DIGEST_SIZE) {
468471 ERROR("bad SHA1 size %d %s\n", len, ptr);
469472 // printf("base64 [%s] => [", ptr);
@@ -474,11 +477,14 @@ int loadAideDatabaseFile(AIDE_CONTEXT *ctx, char *filename) {
474477 break;
475478 case AIDE_ITEM_SHA256: // base64
476479 if (!is_null) {
477- md->sha256 = malloc(SHA256_DIGEST_SIZE);
478- len = decodeBase64(
479- md->sha256,
480- (unsigned char *)ptr,
481- SHA256_BASE64_DIGEST_SIZE);
480+ md->sha256 = decodeBase64(
481+ (char *)ptr,
482+ SHA256_BASE64_DIGEST_SIZE,
483+ &len);
484+ if (md->sha256 == NULL) {
485+ ERROR("decodeBase64 fail");
486+ goto close;
487+ }
482488 if (len != SHA256_DIGEST_SIZE) {
483489 ERROR("bad SHA256 size %d\n", len);
484490 printf("base64 [%s] => [", ptr);
@@ -491,11 +497,14 @@ int loadAideDatabaseFile(AIDE_CONTEXT *ctx, char *filename) {
491497 break;
492498 case AIDE_ITEM_SHA512: // base64
493499 if (!is_null) {
494- md->sha512 = malloc(SHA512_DIGEST_SIZE);
495- len = decodeBase64(
496- md->sha512,
497- (unsigned char *)ptr,
498- SHA512_BASE64_DIGEST_SIZE);
500+ md->sha512 = decodeBase64(
501+ (char *)ptr,
502+ SHA512_BASE64_DIGEST_SIZE,
503+ &len);
504+ if (md->sha512 == NULL) {
505+ ERROR("decodeBase64 fail");
506+ goto close;
507+ }
499508 if (len != SHA512_DIGEST_SIZE) {
500509 ERROR("bad SHA512 size %d\n", len);
501510 printf("base64 [%s] => [", ptr);
@@ -561,7 +570,7 @@ int loadAideDatabaseFile(AIDE_CONTEXT *ctx, char *filename) {
561570 // ignore printf("??? [%s]\n", buf);
562571 } // if
563572 } // while
564-
573+ close:
565574 gzclose(fp);
566575 DEBUG("loadAideDatabaseFile - has %d entries\n", ctx->metadata_num);
567576 DEBUG("loadAideDatabaseFile - done\n");
@@ -816,8 +825,9 @@ int checkEventByAide(AIDE_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *eventWrapper)
816825 TSS_PCR_EVENT *event;
817826 char *name;
818827 int rc = 0;
828+ char *buf;
829+ int buf_len;
819830 #ifdef CONFIG_SQLITE
820- BYTE b64[SHA1_BASE64_DIGEST_SIZE+1];
821831 #else
822832 AIDE_METADATA *md;
823833 #if AIDE_CHBY_LIST
@@ -825,8 +835,7 @@ int checkEventByAide(AIDE_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *eventWrapper)
825835 #else
826836 ENTRY e;
827837 ENTRY *ep;
828- BYTE b64[SHA1_BASE64_DIGEST_SIZE+1];
829-#endif
838+#endif // AIDE_CHBY_LIST
830839 #endif // CONFIG_SQLITE
831840
832841 // DEBUG("checkEventByAide - start\n");
@@ -862,10 +871,16 @@ int checkEventByAide(AIDE_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *eventWrapper)
862871 /* OK, let's find the HIT */
863872 #ifdef CONFIG_SQLITE
864873 /* base64 */
865- encodeBase64(b64, event->rgbEvent, 20);
866- b64[SHA1_BASE64_DIGEST_SIZE] = 0;
867-
868- rc = verifyBySQLite(ctx, (char*)b64);
874+ buf = encodeBase64(
875+ event->rgbEvent,
876+ 20
877+ &buf_len);
878+ if (buf == NULL) {
879+ ERROR("encodeBase64 fail");
880+ return -1;
881+ }
882+ rc = verifyBySQLite(ctx, (char*)buf);
883+ free(buf);
869884
870885 if (rc == OPENPTS_RESULT_VALID) {
871886 /* hit */
@@ -904,10 +919,15 @@ int checkEventByAide(AIDE_CONTEXT *ctx, OPENPTS_PCR_EVENT_WRAPPER *eventWrapper)
904919 DEBUG_FSM("checkFileByAide - MISS\n");
905920 #else // hashtable
906921
907- encodeBase64(b64, event->rgbEvent, 20);
908- b64[SHA1_BASE64_DIGEST_SIZE] = 0;
909-
910- e.key = (char *) b64; // size?
922+ buf = encodeBase64(
923+ event->rgbEvent,
924+ 20,
925+ &buf_len);
926+ if (buf == NULL) {
927+ ERROR("encodeBase64 fail");
928+ return -1;
929+ }
930+ e.key = (char *) buf; // size?
911931 e.data = NULL; // just initialized for static analysys
912932
913933 // before (list)
@@ -1112,7 +1132,8 @@ int convertImlToAideDbFile(OPENPTS_CONTEXT *ctx, char *filename) {
11121132 OPENPTS_SNAPSHOT *ss;
11131133 OPENPTS_PCR_EVENT_WRAPPER *eventWrapper;
11141134 TSS_PCR_EVENT *event;
1115- unsigned char buf[128]; // TODO(munetoh)
1135+ char *buf;
1136+ int buf_len;
11161137 char *aide_filename = NULL;
11171138 int len;
11181139
@@ -1149,7 +1170,6 @@ int convertImlToAideDbFile(OPENPTS_CONTEXT *ctx, char *filename) {
11491170
11501171 // for (i = 0; i < ctx->eventNum; i++) {
11511172 for (i = 0; i < ctx->ss_table->event_num; i++) { // TODO ss->event_num?
1152- memset(buf, 0, sizeof(buf));
11531173 // DEBUG("SM DEBUG event %p\n",event);
11541174
11551175 if (event == NULL) {
@@ -1188,8 +1208,16 @@ int convertImlToAideDbFile(OPENPTS_CONTEXT *ctx, char *filename) {
11881208 }
11891209
11901210 /* digest */
1191- encodeBase64(buf, (unsigned char *)event->rgbEvent, SHA1_DIGEST_SIZE);
1211+ buf = encodeBase64(
1212+ (unsigned char *)event->rgbEvent,
1213+ SHA1_DIGEST_SIZE,
1214+ &buf_len);
1215+ if (buf == NULL) {
1216+ ERROR("encodeBase64 fail");
1217+ goto close;
1218+ }
11921219 gzprintf(fp, "%s \n", buf);
1220+ free(buf);
11931221
11941222 // printf("%d %s\n", i, buf);
11951223
@@ -1233,7 +1261,8 @@ int writeReducedAidbDatabase(AIDE_CONTEXT *ctx, char *filename) {
12331261 AIDE_METADATA *md;
12341262 int i;
12351263 int cnt = 0;
1236- unsigned char buf[128]; // TODO(munetoh)
1264+ char *buf;
1265+ int buf_len;
12371266
12381267 DEBUG("writeReducedAidbDatabase %s\n", filename);
12391268
@@ -1263,10 +1292,17 @@ int writeReducedAidbDatabase(AIDE_CONTEXT *ctx, char *filename) {
12631292
12641293 if (md->status == OPENPTS_AIDE_MD_STATUS_HIT) {
12651294 // printf("+");
1266- memset(buf, 0, sizeof(buf));
1267- encodeBase64(buf, (unsigned char *)md->sha1, SHA1_DIGEST_SIZE);
1295+ buf = encodeBase64(
1296+ (unsigned char *)md->sha1,
1297+ SHA1_DIGEST_SIZE,
1298+ &buf_len);
1299+ if (buf == NULL) {
1300+ ERROR("encodeBase64 fail");
1301+ return -1;
1302+ }
12681303 gzprintf(fp, "%s ", md->name);
12691304 gzprintf(fp, "%s \n", buf);
1305+ free(buf);
12701306 cnt++;
12711307 }
12721308
--- a/src/base64.c
+++ b/src/base64.c
@@ -26,9 +26,11 @@
2626 * \brief Base64 Encode/Decode
2727 * @author Seiji Munetoh <munetoh@users.sourceforge.jp>
2828 * @date 2010-04-01
29- * cleanup 2011-01-22 SM
29+ * cleanup 2011-08-17 SM
3030 *
3131 * http://en.wikipedia.org/wiki/Base64
32+ *
33+ * 2011-08-17 SM - encodebase64 & decodeBase64 - alloc output buffer
3234 */
3335
3436 #include <stdio.h>
@@ -38,9 +40,12 @@
3840 #include <openpts.h>
3941
4042 /**
41- * calc base64 size
42- */
43-int base64size(int len) {
43+ * calc base64 size
44+ *
45+ * string(or binary data) => base64 string + 1
46+ * Output is actual string size + 1 (for \0)
47+ */
48+int _sizeofBase64Encode(int len) {
4449 /* check */
4550 if (len < 0) return 0;
4651 if (len == 0) return 1;
@@ -49,9 +54,26 @@ int base64size(int len) {
4954 }
5055
5156 /**
52- * Encode BYTE[] to Base64 string
53- */
54-int encodeBase64(unsigned char *out, unsigned char * in, int len) {
57+ * calc original data size from base64 string size
58+ *
59+ * This is rough estimation.
60+ * Output is actual string size (+1 or +2) + 1 (for \0)
61+ *
62+ */
63+int _sizeofBase64Decode(int len) {
64+ /* check */
65+ if (len < 0) return 0;
66+ if (len == 0) return 1;
67+
68+ return (len / 4 * 3) + 1;
69+}
70+
71+
72+
73+/**
74+ * Encode BYTE[] to Base64 string
75+ */
76+int _encodeBase64(char *out, unsigned char * in, int len) {
5577 int ptr1 = 0;
5678 int ptr2 = 0;
5779
@@ -112,10 +134,42 @@ int encodeBase64(unsigned char *out, unsigned char * in, int len) {
112134 }
113135 }
114136
137+ /* add \0 at the end of buffer */
115138 out[ptr2] = 0;
139+
116140 return ptr2;
117141 }
142+/**
143+ * Encode BYTE[] to Base64 string
144+ *
145+ * @param *in buffer of input data
146+ * @param inlen length
147+ * @raram *outlen size of output
148+ * @return *out Base64 string, malloc new buffer
149+ */
150+char *encodeBase64(unsigned char * in, int inlen, int *outlen) {
151+ char *out;
152+ int len2;
153+
154+ *outlen = _sizeofBase64Encode(inlen);
155+ out = (char *) malloc(*outlen);
156+ if (out == NULL) {
157+ ERROR("no memory");
158+ *outlen = 0;
159+ return NULL;
160+ }
161+ memset(out,0,*outlen);
162+
163+ len2 = _encodeBase64(out, in, inlen);
164+ if (len2 > *outlen) {
165+ ERROR("fatal error");
166+ free(out);
167+ *outlen = 0;
168+ return NULL;
169+ }
118170
171+ return out;
172+}
119173
120174 /**
121175 * return length - TBD
@@ -141,13 +195,15 @@ unsigned char trans(unsigned char in) {
141195 /**
142196 * Decode Base64 string to BYTE[]
143197 *
198+ * caller must provide the buffer
199+ *
144200 * return size of BYTE[] array
145201 */
146-int decodeBase64core(unsigned char *out, unsigned char * in, int len) {
147- int ptr1 = 0;
148- int ptr2 = 0;
202+int _decodeBase64core(unsigned char *out, char * in, int len) {
203+ int ptr1 = 0; // in
204+ int ptr2 = 0; // out
149205 int len2;
150- unsigned char * in2;
206+ char * in2;
151207
152208 /* check */
153209 if (out ==NULL) {
@@ -206,17 +262,24 @@ int decodeBase64core(unsigned char *out, unsigned char * in, int len) {
206262 }
207263 }
208264
209- // DEBUG("base64 [%s] > [%s]\n",in, out);
210- // not here, binnary data is also decoded out[ptr2]=0; // put \0
265+
266+ /* Anyway, add \0 at the end of buffer */
267+ // TODO("out[%d] = 0\n", ptr2);
268+ out[ptr2] = 0;
269+
211270 return ptr2;
212271 }
213272
214273
215274 /**
216- * remove space CR
275+ * remove space & CR in Base64 string
276+ *
277+ * @param *in Base64 string buffer
278+ * @param *len size of buffer, before and after
279+ * @return new Base64 string buffer (malloced)
217280 */
218-unsigned char * removeCR(unsigned char *in, int *len) {
219- unsigned char *out;
281+char * _removeCR(char *in, int *len) {
282+ char *out;
220283 int i;
221284 int j = 0;
222285
@@ -231,31 +294,74 @@ unsigned char * removeCR(unsigned char *in, int *len) {
231294 /* skip */
232295 // DEBUG("SP\n");
233296 } else {
297+ /* valid data */
234298 out[j]=in[i];
235299 j++;
236300 }
237301 }
238302
239303 *len = j;
304+ // note)
305+ // if there are no skip, it return same buffer
306+ // if there are skip, out[j] is 0, since memset(0) before
240307
241308 return out;
242309 }
243310
244311 /**
245- * Decode Base64(with CRLF) string to BYTE[]
312+ * Decode Base64(with CRLF) string to BYTE[]
246313 *
247- * return size of BYTE[] array
314+ * @param *out
315+ * @param *in
316+ * @param *len
317+ * @return size of BYTE[] array
248318 */
249-int decodeBase64(unsigned char *out, unsigned char * in, int len) {
319+int _decodeBase64(unsigned char *out, char * in, int len) {
250320 int rc;
251- unsigned char * in2;
321+ char * in2;
252322 int len2 = len;
253323
254- in2 = removeCR(in, &len2);
324+ in2 = _removeCR(in, &len2);
255325
256- rc = decodeBase64core(out, in2, len2);
326+ rc = _decodeBase64core(out, in2, len2);
257327
258328 free(in2);
259329
260330 return rc;
261331 }
332+
333+/**
334+ * Decode Base64(with CRLF) string to BYTE[]
335+ *
336+ * @param *in buffer of base64 string
337+ * @param inlen length
338+ * @raram *outlen size of BYTE[] array from base64 string, malloced size is bigger then this
339+ * @return *out malloc new buffer
340+ */
341+unsigned char *decodeBase64(char * in, int inlen, int *outlen) {
342+ unsigned char *out;
343+ int len1;
344+ int len2;
345+
346+ len1 = _sizeofBase64Decode(inlen);
347+ out = (unsigned char *) malloc(len1);
348+ if (out == NULL) {
349+ ERROR("no memory");
350+ *outlen = 0;
351+ return NULL;
352+ }
353+ memset(out,0,len1);
354+
355+ len2 = _decodeBase64(out, in, inlen);
356+ if (len2 > len1) {
357+ ERROR("fatal error");
358+ free(out);
359+ *outlen = 0;
360+ return NULL;
361+ }
362+
363+ /* return actial data size created from base64 */
364+ *outlen = len2;
365+
366+ return out;
367+}
--- a/src/conf.c
+++ b/src/conf.c
@@ -351,6 +351,7 @@ int readPtsConfig(OPENPTS_CONFIG *conf, char *filename) {
351351 int len;
352352 char *path;
353353 char *filename2 = NULL; // fullpath
354+ int buf_len;
354355
355356 DEBUG("readPtsConfig() : %s\n", filename);
356357
@@ -798,19 +799,18 @@ int readPtsConfig(OPENPTS_CONFIG *conf, char *filename) {
798799 }
799800 /* PUBKEY */
800801 if (!strncmp(name, "target.pubkey", 13)) {
801- // TODO used by two
802802 if (conf->pubkey != NULL) {
803- // DEBUG("realloc conf->pubkey\n"); // TODO realloc happen
804803 free(conf->pubkey);
805804 }
806-
807- conf->pubkey = malloc(strlen(value)); // TODO too big:-P
808- rc = decodeBase64(conf->pubkey, (BYTE *)value, strlen(value));
809- if (rc < 0) {
810- ERROR("read PUBKEY fail rc=%d\n", rc);
805+ conf->pubkey = decodeBase64(
806+ (char *)value,
807+ strlen(value),
808+ &buf_len);
809+ if (conf->pubkey == NULL) {
810+ ERROR("decodeBase64");
811811 conf->pubkey_length = 0;
812812 } else {
813- conf->pubkey_length = rc;
813+ conf->pubkey_length = buf_len;
814814 DEBUG("pubkey length : %d\n", conf->pubkey_length);
815815 }
816816 }
@@ -958,8 +958,12 @@ int writeTargetConf(OPENPTS_CONFIG *conf, PTS_UUID *uuid, char *filename) {
958958
959959 if (conf->pubkey_length > 0) {
960960 char *buf; // TODO
961- buf = malloc(1000);
962- encodeBase64((unsigned char *)buf, (unsigned char *)conf->pubkey, conf->pubkey_length);
961+ int buf_len;
962+
963+ buf = encodeBase64(
964+ (unsigned char *)conf->pubkey,
965+ conf->pubkey_length,
966+ &buf_len);
963967 fprintf(fp, "target.pubkey=%s\n", buf); // base64
964968 free(buf);
965969 }
--- a/src/fsm.c
+++ b/src/fsm.c
@@ -373,6 +373,7 @@ int getDigestFlag(char * cond, BYTE **digest, int *digest_size) {
373373 int len;
374374 int rc = 0;
375375 BYTE *buf;
376+ int buf_len;
376377
377378 DEBUG_CAL("getDigestFlag -");
378379
@@ -431,27 +432,20 @@ int getDigestFlag(char * cond, BYTE **digest, int *digest_size) {
431432 } else {
432433 /* Binary Model */
433434 /* Base64 str -> BYTE[] */
434- buf = (BYTE *) malloc(SHA1_DIGEST_SIZE + 1);
435+ buf = decodeBase64(
436+ (char *)loc,
437+ SHA1_BASE64_DIGEST_SIZE,
438+ &buf_len);
435439 if (buf == NULL) {
436- ERROR("no memory");
437- return -1;
438- }
439-
440- // TODO(munetoh) get len, "<"
441- rc = decodeBase64(buf, (unsigned char *)loc, SHA1_BASE64_DIGEST_SIZE);
442- if (rc == SHA1_DIGEST_SIZE) {
443- // TODO(munetoh) digest size change by alg
444- // this code is SHA1 only
445- *digest = buf;
446- *digest_size = rc;
447- return 1;
448- } else {
449- ERROR("getDigestFlag() - decodeBase64() was failed \n");
450- free(buf);
440+ ERROR("decodeBase64 fail");
451441 *digest = NULL;
452442 *digest_size = 0;
453443 return -1;
454444 }
445+ *digest = buf;
446+ // TODO buf_len >= SHA1_DIGEST_SIZE
447+ *digest_size = SHA1_DIGEST_SIZE;
448+ return 1;
455449 }
456450 }
457451 }
--- a/src/ifm.c
+++ b/src/ifm.c
@@ -239,7 +239,7 @@ PTS_IF_M_Attribute *readPtsTlv(int fdin) {
239239 return read_tlv;
240240
241241 error:
242- if (read_msg != NULL) free(read_msg);
242+ // if (read_msg != NULL) free(read_msg);
243243 if (read_tlv != NULL) freePtsTlv(read_tlv);
244244 return NULL;
245245 }
--- a/src/iml2text.c
+++ b/src/iml2text.c
@@ -24,7 +24,7 @@
2424 * \brief Convert binary IML file to plaintext
2525 * @author Seiji Munetoh <munetoh@users.sourceforge.jp>
2626 * @date 2010-08-25
27- * cleanup 2011-05-31 SM
27+ * cleanup 2011-08-17 SM
2828 *
2929 * show eventlog (get though TSS)
3030 *
@@ -260,7 +260,8 @@ void fprintEventData(
260260 UINT32 type,
261261 BYTE* digest) {
262262 char buf[BUFSIZE];
263- char b64buf[BUFSIZE];
263+ char *b64buf; //[BUFSIZE];
264+ int b64buf_len;
264265 int i;
265266
266267 if (len < BUFSIZE) {
@@ -717,11 +718,18 @@ EventData
717718 for (i = 0; i < (int)len; i++) {
718719 fprintf(fp, "%02x", (BYTE)buf[i]);
719720 }
720- encodeBase64(
721- (unsigned char *)b64buf,
722- (unsigned char *)buf, len);
723- fprintf(fp, ", base64(%s)", b64buf);
724- fprintf(fp, "]");
721+ b64buf = encodeBase64(
722+ //(unsigned char *)b64buf,
723+ (unsigned char *)buf,
724+ len,
725+ &b64buf_len);
726+ if (b64buf == NULL) {
727+ ERROR("encodeBase64 fail");
728+ } else {
729+ fprintf(fp, ", base64(%s)", b64buf);
730+ fprintf(fp, "]");
731+ free(b64buf);
732+ }
725733 } else {
726734 fprintf(fp, "[Unknown Event:size=%d] ", len);
727735 }
--- a/src/imv.c
+++ b/src/imv.c
@@ -847,7 +847,7 @@ TNC_IMV_API TNC_Result TNC_IMV_SolicitRecommendation(
847847
848848
849849 if (result == OPENPTS_RESULT_VALID) {
850- TODO("verifier() result : VALID");
850+ DEBUG("verifier() result : VALID");
851851 str = (TNC_BufferReference)"valid";
852852 recommendation = TNC_IMV_ACTION_RECOMMENDATION_ALLOW;
853853 evaluation = TNC_IMV_EVALUATION_RESULT_COMPLIANT;
--- a/src/ir.c
+++ b/src/ir.c
@@ -219,7 +219,6 @@ int writeComponentID(
219219 }
220220
221221 /* Add an attribute with name "SimpleName" */
222-
223222 rc = xmlTextWriterWriteAttribute(
224223 writer,
225224 BAD_CAST "SimpleName",
@@ -230,7 +229,6 @@ int writeComponentID(
230229 }
231230
232231 /* Add an attribute with name "VersionBuild" */
233-
234232 rc = xmlTextWriterWriteAttribute(
235233 writer,
236234 BAD_CAST "VersionBuild",
@@ -516,7 +514,7 @@ int writePcrHash(
516514 BYTE * hash,
517515 int algtype) {
518516 // int rc = PTS_SUCCESS;
519- char id[256]; // TODO(munetoh)
517+ char id[256]; // TODO(munetoh) 11+1+1 = 12?
520518
521519 DEBUG_CAL("writePcrHash - PCR[%d] level %d \n", pcrIndex, ss_level);
522520
@@ -591,7 +589,7 @@ int writeSnapshot(
591589 int j;
592590 PTS_UUID *ir_uuid;
593591 char *str_ir_uuid;
594- char id[256];
592+ char id[256]; // TODO 3 + UUID = 3 + 36 = 39
595593 int level;
596594
597595 level = ss->level;
@@ -786,10 +784,12 @@ int writeQuote(
786784 OPENPTS_CONTEXT *ctx) {
787785 int rc;
788786 int i;
789- char buf[BUF_SIZE];
787+ char *b64buf = NULL;
788+ int b64buf_len;
790789 int size_of_select = 0;
791790 int select_int = 0;
792- BYTE select_byte[3];
791+ BYTE select_byte[3]; // TODO TPM1.2, 24PCRs => 3 bytes
792+ char tagbuf[128];
793793
794794 if (ctx->pcrs == NULL) {
795795 TODO("writeQuote - OPENPTS_PCRS is NULL, SKIP QuoteData\n");
@@ -861,23 +861,29 @@ int writeQuote(
861861 }
862862
863863 /* Add an attribute with name "SizeOfSelect", int */
864- snprintf(buf, sizeof(buf), "%d", size_of_select);
865- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "SizeOfSelect", BAD_CAST buf);
864+ snprintf(tagbuf, sizeof(tagbuf), "%d", size_of_select);
865+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "SizeOfSelect", BAD_CAST tagbuf);
866866 if (rc < 0) {
867867 ERROR("Error at xmlTextWriterWriteAttribute\n");
868868 return PTS_INTERNAL_ERROR;
869869 }
870870
871871 /* Add an attribute with name "PcrSelect", base64 */
872- encodeBase64(
873- (unsigned char *)buf,
872+ b64buf = (char *)encodeBase64(
874873 (unsigned char *)select_byte,
875- size_of_select);
876- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "PcrSelect", BAD_CAST buf);
874+ size_of_select,
875+ &b64buf_len);
876+ if (b64buf == NULL) {
877+ ERROR("encodeBase64 fail");
878+ return PTS_INTERNAL_ERROR;
879+ }
880+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "PcrSelect", BAD_CAST b64buf);
877881 if (rc < 0) {
878882 ERROR("Error at xmlTextWriterWriteAttribute\n");
879883 return PTS_INTERNAL_ERROR;
880884 }
885+ free(b64buf);
886+ b64buf = NULL;
881887
882888 /* Close the element named "PcrSelection". */
883889 rc = xmlTextWriterEndElement(writer);
@@ -906,8 +912,8 @@ int writeQuote(
906912 return PTS_INTERNAL_ERROR;
907913 }
908914 /* Add an attribute with name "PcrNumber", int */
909- snprintf(buf, sizeof(buf), "%d", i);
910- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "PcrNumber", BAD_CAST buf);
915+ snprintf(tagbuf, sizeof(tagbuf), "%d", i);
916+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "PcrNumber", BAD_CAST tagbuf);
911917 // rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "PcrNumber", BAD_CAST "0");
912918 if (rc < 0) {
913919 ERROR("Error at xmlTextWriterWriteAttribute\n");
@@ -950,69 +956,77 @@ int writeQuote(
950956 }
951957
952958 /* Add an attribute with name "VersionMajor", int */
953- snprintf(buf, sizeof(buf), "%d", ctx->validation_data->versionInfo.bMajor);
954- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "VersionMajor", BAD_CAST buf);
959+ snprintf(tagbuf, sizeof(tagbuf), "%d", ctx->validation_data->versionInfo.bMajor);
960+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "VersionMajor", BAD_CAST tagbuf);
955961 if (rc < 0) {
956962 ERROR("Error at xmlTextWriterWriteAttribute\n");
957963 return PTS_INTERNAL_ERROR;
958964 }
959965 /* Add an attribute with name "VersionMinor", int */
960- snprintf(buf, sizeof(buf), "%d", ctx->validation_data->versionInfo.bMinor);
961- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "VersionMinor", BAD_CAST buf);
966+ snprintf(tagbuf, sizeof(tagbuf), "%d", ctx->validation_data->versionInfo.bMinor);
967+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "VersionMinor", BAD_CAST tagbuf);
962968 if (rc < 0) {
963969 ERROR("Error at xmlTextWriterWriteAttribute\n");
964970 return PTS_INTERNAL_ERROR;
965971 }
966972 /* Add an attribute with name "VersionRevMajor", int */
967- snprintf(buf, sizeof(buf), "%d", ctx->validation_data->versionInfo.bRevMajor);
968- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "VersionRevMajor", BAD_CAST buf);
973+ snprintf(tagbuf, sizeof(tagbuf), "%d", ctx->validation_data->versionInfo.bRevMajor);
974+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "VersionRevMajor", BAD_CAST tagbuf);
969975 if (rc < 0) {
970976 ERROR("Error at xmlTextWriterWriteAttribute\n");
971977 return PTS_INTERNAL_ERROR;
972978 }
979+
973980 /* Add an attribute with name "VersionRevMinor", int */
974- snprintf(buf, sizeof(buf), "%d", ctx->validation_data->versionInfo.bRevMinor);
975- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "VersionRevMinor", BAD_CAST buf);
981+ snprintf(tagbuf, sizeof(tagbuf), "%d", ctx->validation_data->versionInfo.bRevMinor);
982+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "VersionRevMinor", BAD_CAST tagbuf);
976983 if (rc < 0) {
977984 ERROR("Error at xmlTextWriterWriteAttribute\n");
978985 return PTS_INTERNAL_ERROR;
979986 }
987+
980988 /* Add an attribute with name "Fixed", int */
981989 rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "Fixed", BAD_CAST "QUOT");
982990 if (rc < 0) {
983991 ERROR("Error at xmlTextWriterWriteAttribute\n");
984992 return -1;
985993 }
994+
986995 /* Add an attribute with name "DigestValue", base64 */
987- // 2011-02-07 bad DigestValue
988- // encodeBase64(
989- // (unsigned char *)buf,
990- // (unsigned char *)ctx->validation_data->rgbData,
991- // ctx->validation_data->ulDataLength);
992- encodeBase64(
993- (unsigned char *)buf,
996+ b64buf = encodeBase64(
994997 (unsigned char *)&ctx->validation_data->rgbData[8], // skip 01010000 51554f54
995- 20); // ctx->validation_data->ulDataLength);
996- // DEBUG("rgbData b64=%s\n", buf);
997- // printHex("\t\trgbData",ctx->validation_data->rgbData, ctx->validation_data->ulDataLength,"\n");
998- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "DigestValue", BAD_CAST buf);
998+ 20,
999+ &b64buf_len); // ctx->validation_data->ulDataLength);
1000+ if (b64buf == NULL) {
1001+ ERROR("encodeBase64() fail");
1002+ return PTS_INTERNAL_ERROR;
1003+ }
1004+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "DigestValue", BAD_CAST b64buf);
9991005 if (rc < 0) {
10001006 ERROR("Error at xmlTextWriterWriteAttribute\n");
10011007 return PTS_INTERNAL_ERROR;
10021008 }
1009+ free(b64buf);
1010+ b64buf=NULL;
10031011
10041012 // TODO we used DH-nonce exchange but here, we put plain nonce:-P
10051013 // TODO is this option attribute? can we suppress?
10061014 /* Add an attribute with name "ExternalData", base64 */
1007- encodeBase64(
1008- (unsigned char *)buf,
1015+ b64buf = encodeBase64(
10091016 (unsigned char *)ctx->validation_data->rgbExternalData,
1010- ctx->validation_data->ulExternalDataLength);
1011- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "ExternalData", BAD_CAST buf);
1017+ ctx->validation_data->ulExternalDataLength,
1018+ &b64buf_len);
1019+ if (b64buf == NULL) {
1020+ ERROR("encodeBase64() fail");
1021+ return PTS_INTERNAL_ERROR;
1022+ }
1023+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "ExternalData", BAD_CAST b64buf);
10121024 if (rc < 0) {
10131025 ERROR("Error at xmlTextWriterWriteAttribute\n");
10141026 return PTS_INTERNAL_ERROR;
10151027 }
1028+ free(b64buf);
1029+ b64buf=NULL;
10161030
10171031 /* Close the element named "QuoteInfo". */
10181032 rc = xmlTextWriterEndElement(writer);
@@ -1123,14 +1137,15 @@ int writeQuote2(
11231137 OPENPTS_CONTEXT *ctx) {
11241138 int rc;
11251139 int i;
1126- char buf[BUF_SIZE];
1140+ char *b64buf = NULL;
1141+ int b64buf_len;
11271142 int size_of_select = 0;
11281143 BYTE select_byte[3];
11291144 int tag;
11301145 char fixed[5];
11311146 int locality;
1132- // BYTE *external_data;
11331147 BYTE *composite_hash;
1148+ char tagbuf[128]; // Quote tag
11341149
11351150 if (ctx->pcrs == NULL) {
11361151 TODO("writeQuote2 - OPENPTS_PCRS is NULL, SKIP QuoteData\n");
@@ -1198,8 +1213,8 @@ int writeQuote2(
11981213 }
11991214
12001215 /* QuoteInfo2 - attribute - Tag */
1201- snprintf(buf, sizeof(buf), "%d", tag);
1202- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "Tag", BAD_CAST buf);
1216+ snprintf(tagbuf, sizeof(tagbuf), "%d", tag);
1217+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "Tag", BAD_CAST tagbuf);
12031218 if (rc < 0) {
12041219 ERROR("Error at xmlTextWriterWriteAttribute\n");
12051220 return PTS_INTERNAL_ERROR;
@@ -1212,11 +1227,16 @@ int writeQuote2(
12121227 return -1;
12131228 }
12141229 /* QuoteInfo2 - attribute - ExternalData - base64 */
1215- encodeBase64(
1216- (unsigned char *)buf,
1230+ b64buf = encodeBase64(
12171231 (unsigned char *)ctx->validation_data->rgbExternalData,
1218- ctx->validation_data->ulExternalDataLength);
1219- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "ExternalData", BAD_CAST buf);
1232+ ctx->validation_data->ulExternalDataLength,
1233+ &b64buf_len);
1234+ if (b64buf == NULL) {
1235+ ERROR("encodeBase64 fail");
1236+ return PTS_INTERNAL_ERROR;
1237+ }
1238+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "ExternalData", BAD_CAST b64buf);
1239+ free(b64buf);
12201240 if (rc < 0) {
12211241 ERROR("Error at xmlTextWriterWriteAttribute\n");
12221242 return PTS_INTERNAL_ERROR;
@@ -1236,18 +1256,23 @@ int writeQuote2(
12361256 return PTS_INTERNAL_ERROR;
12371257 }
12381258 /* Add an attribute with name "SizeOfSelect", int */
1239- snprintf(buf, sizeof(buf), "%d", size_of_select);
1240- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "SizeOfSelect", BAD_CAST buf);
1259+ snprintf(tagbuf, sizeof(tagbuf), "%d", size_of_select);
1260+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "SizeOfSelect", BAD_CAST tagbuf);
12411261 if (rc < 0) {
12421262 ERROR("Error at xmlTextWriterWriteAttribute\n");
12431263 return PTS_INTERNAL_ERROR;
12441264 }
12451265 /* Add an attribute with name "PcrSelect", base64 */
1246- encodeBase64(
1247- (unsigned char *)buf,
1266+ b64buf = encodeBase64(
12481267 (unsigned char *)select_byte,
1249- size_of_select);
1250- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "PcrSelect", BAD_CAST buf);
1268+ size_of_select,
1269+ &b64buf_len);
1270+ if (b64buf == NULL) {
1271+ ERROR("encodeBase64 fail");
1272+ return PTS_INTERNAL_ERROR;
1273+ }
1274+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "PcrSelect", BAD_CAST b64buf);
1275+ free(b64buf);
12511276 if (rc < 0) {
12521277 ERROR("Error at xmlTextWriterWriteAttribute\n");
12531278 return PTS_INTERNAL_ERROR;
@@ -1268,11 +1293,16 @@ int writeQuote2(
12681293 }
12691294
12701295 /* CompositeHash - element */
1271- encodeBase64(
1272- (unsigned char *)buf,
1296+ b64buf = encodeBase64(
12731297 (unsigned char *)composite_hash,
1274- 20);
1275- rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CompositeHash", "%s", buf);
1298+ 20,
1299+ &b64buf_len);
1300+ if (b64buf == NULL) {
1301+ ERROR("encodeBase64 fail");
1302+ return PTS_INTERNAL_ERROR;
1303+ }
1304+ rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CompositeHash", "%s", b64buf);
1305+ free(b64buf);
12761306 if (rc < 0) {
12771307 ERROR("Error at xmlTextWriterWriteFormatElement\n");
12781308 return PTS_INTERNAL_ERROR;
@@ -1293,18 +1323,23 @@ int writeQuote2(
12931323 return PTS_INTERNAL_ERROR;
12941324 }
12951325 /* Add an attribute with name "SizeOfSelect", int */
1296- snprintf(buf, sizeof(buf), "%d", size_of_select);
1297- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "SizeOfSelect", BAD_CAST buf);
1326+ snprintf(tagbuf, sizeof(tagbuf), "%d", size_of_select);
1327+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "SizeOfSelect", BAD_CAST tagbuf);
12981328 if (rc < 0) {
12991329 ERROR("Error at xmlTextWriterWriteAttribute\n");
13001330 return PTS_INTERNAL_ERROR;
13011331 }
13021332 /* Add an attribute with name "PcrSelect", base64 */
1303- encodeBase64(
1304- (unsigned char *)buf,
1333+ b64buf = encodeBase64(
13051334 (unsigned char *)select_byte,
1306- size_of_select);
1307- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "PcrSelect", BAD_CAST buf);
1335+ size_of_select,
1336+ &b64buf_len);
1337+ if (b64buf == NULL) {
1338+ ERROR("encodeBase64 fail");
1339+ return PTS_INTERNAL_ERROR;
1340+ }
1341+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "PcrSelect", BAD_CAST b64buf);
1342+ free(b64buf);
13081343 if (rc < 0) {
13091344 ERROR("Error at xmlTextWriterWriteAttribute\n");
13101345 return PTS_INTERNAL_ERROR;
@@ -1331,8 +1366,8 @@ int writeQuote2(
13311366 return PTS_INTERNAL_ERROR;
13321367 }
13331368 /* Add an attribute - PcrNumber - int */
1334- snprintf(buf, sizeof(buf), "%d", i);
1335- rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "PcrNumber", BAD_CAST buf);
1369+ snprintf(tagbuf, sizeof(tagbuf), "%d", i);
1370+ rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "PcrNumber", BAD_CAST tagbuf);
13361371 if (rc < 0) {
13371372 ERROR("Error at xmlTextWriterWriteAttribute\n");
13381373 return PTS_INTERNAL_ERROR;
@@ -1481,11 +1516,10 @@ int writeQuote2(
14811516 */
14821517 // TODO remove file
14831518 int writeIr(OPENPTS_CONTEXT *ctx, const char *file) {
1484-// int writeIr(OPENPTS_CONTEXT *ctx) {
14851519 int rc = PTS_SUCCESS;
14861520 int i;
14871521 xmlTextWriterPtr writer;
1488- xmlBufferPtr buf;
1522+ xmlBufferPtr xmlbuf;
14891523 FILE *fp;
14901524 PTS_ComponentId cid;
14911525 OPENPTS_TPM_CONTEXT tpm; // to calc snapshot PCR
@@ -1543,15 +1577,15 @@ int writeIr(OPENPTS_CONTEXT *ctx, const char *file) {
15431577 resetTpm(&tpm, ctx->drtm);
15441578
15451579 /* Create a new XML buffer */
1546- buf = xmlBufferCreate();
1547- if (buf == NULL) {
1580+ xmlbuf = xmlBufferCreate();
1581+ if (xmlbuf == NULL) {
15481582 ERROR("creating the xml buffer fail\n");
15491583 rc = PTS_INTERNAL_ERROR;
15501584 goto error;
15511585 }
15521586
15531587 /* Create a new XmlWriter for memory */
1554- writer = xmlNewTextWriterMemory(buf, 0);
1588+ writer = xmlNewTextWriterMemory(xmlbuf, 0);
15551589 if (writer == NULL) {
15561590 ERROR("creating the xml writer fail\n");
15571591 rc = PTS_INTERNAL_ERROR;
@@ -1754,7 +1788,7 @@ int writeIr(OPENPTS_CONTEXT *ctx, const char *file) {
17541788 goto free;
17551789 }
17561790
1757- fprintf(fp, "%s", (const char *) buf->content);
1791+ fprintf(fp, "%s", (const char *) xmlbuf->content);
17581792
17591793 rc = PTS_SUCCESS; // 0
17601794
@@ -1765,7 +1799,7 @@ int writeIr(OPENPTS_CONTEXT *ctx, const char *file) {
17651799 free(str_ir_uuid);
17661800
17671801 freexml:
1768- xmlBufferFree(buf);
1802+ xmlBufferFree(xmlbuf);
17691803
17701804 error:
17711805
@@ -1834,14 +1868,13 @@ void irStartElement(void* ctx, const xmlChar* name, const xmlChar** atts) {
18341868 OPENPTS_IR_CONTEXT * ir_ctx = pctx->ir_ctx;
18351869 TSS_VALIDATION *validation_data = pctx->validation_data;
18361870 OPENPTS_PCRS *pcrs = pctx->pcrs;
1837- BYTE buf[IR_SAX_BUFFER_SIZE]; // TODO
1871+ BYTE *b64buf = NULL;
1872+ int b64buf_len;
18381873 int i;
18391874 char *type;
18401875 char *value;
1841- int rc = 0;
18421876
18431877 ir_ctx->char_size = 0;
1844- // memset(buf, 0, IR_SAX_BUFFER_SIZE); // UNINIT
18451878
18461879 if (!strcmp((char *)name, "Report")) {
18471880 //
@@ -1950,10 +1983,15 @@ void irStartElement(void* ctx, const xmlChar* name, const xmlChar** atts) {
19501983 // DEBUG("SizeOfSelect = %d\n", ir_ctx->pcr_select_size);
19511984 }
19521985 if (!strcmp(type, "PcrSelect")) {
1953- rc = decodeBase64(
1954- buf, // ir_ctx->pcr_select,
1955- (unsigned char *)value,
1956- strlen(value));
1986+ /* used later */
1987+ if (b64buf != NULL) {
1988+ ERROR("bad memory management");
1989+ free(b64buf);
1990+ }
1991+ b64buf = (BYTE *) decodeBase64(
1992+ (char *)value,
1993+ strlen(value),
1994+ &b64buf_len);
19571995 attr_cnt++;
19581996 // DEBUG("PcrSelect = 0x%02x %02x %02x \n", buf[0],buf[1],buf[2]);
19591997 }
@@ -1971,12 +2009,21 @@ void irStartElement(void* ctx, const xmlChar* name, const xmlChar** atts) {
19712009 if (pcrs->pcr_select_byte == NULL) {
19722010 ERROR("no memory\n");
19732011 } else {
1974- memcpy(pcrs->pcr_select_byte, buf, pcrs->pcr_select_size);
2012+ if (b64buf != NULL) {
2013+ memcpy(pcrs->pcr_select_byte, b64buf, pcrs->pcr_select_size);
2014+ } else {
2015+ ERROR("pcr_select_byte is missing");
2016+ }
19752017 }
19762018 } else {
19772019 /* BAD IR */
19782020 ERROR("BAD IR SizeOfSelect or PcrSelect are missing\n");
19792021 }
2022+ /* free Base64 buffer */
2023+ if (b64buf != NULL) {
2024+ free(b64buf);
2025+ b64buf=NULL;
2026+ }
19802027 } else if (!strcmp((char *)name, "ValueSize")) {
19812028 // <ValueSize>200</ValueSize>
19822029 // Text => ctx->pcrs->value_size - irEndElement()
@@ -2044,32 +2091,40 @@ void irStartElement(void* ctx, const xmlChar* name, const xmlChar** atts) {
20442091 }
20452092 if (!strcmp(type, "DigestValue")) {
20462093 // TODO check buf len
2047- rc = decodeBase64(
2048- buf,
2049- (unsigned char *)value,
2050- strlen(value));
2051- // TODO check rc must be 20 (SHA1)
2052- // validation_data->ulDataLength = 48;
2053- // validation_data->rgbData = malloc(48);
2054- // memcpy(validation_data->rgbData, buf, rc);
2055- memcpy(&validation_data->rgbData[8], buf, 20);
2056-
2057- // DEBUG("validation_data->ulDataLength %d < %s\n",validation_data->ulDataLength,value);
2094+ b64buf = decodeBase64(
2095+ (char *)value,
2096+ strlen(value),
2097+ &b64buf_len);
2098+ if (b64buf == NULL) {
2099+ ERROR("decodeBase64 fail");
2100+ ir_ctx->sax_error++;
2101+ return;
2102+ }
2103+ if (b64buf_len < 20) {
2104+ ERROR("decodeBase64 out is too small, %d < 20", b64buf_len);
2105+ ir_ctx->sax_error++;
2106+ return;
2107+ }
2108+ memcpy(&validation_data->rgbData[8], b64buf, 20);
2109+ free(b64buf);
20582110 }
20592111 if (!strcmp(type, "ExternalData")) {
2060- // TODO check buf len
2061- rc = decodeBase64(
2062- buf,
2063- (unsigned char *)value,
2064- strlen(value));
2065- // TODO check rc
2066- validation_data->ulExternalDataLength = rc;
2112+ b64buf = decodeBase64(
2113+ (char *)value,
2114+ strlen(value),
2115+ &b64buf_len);
2116+ if (b64buf == NULL) {
2117+ ERROR("decodeBase64 fail");
2118+ ir_ctx->sax_error++;
2119+ return;
2120+ }
2121+ validation_data->ulExternalDataLength = b64buf_len;
20672122 if (validation_data->rgbExternalData != NULL) {
20682123 free(validation_data->rgbExternalData);
20692124 }
2070- validation_data->rgbExternalData = malloc(rc);
2071- memcpy(validation_data->rgbExternalData, buf, rc);
2072- memcpy(&validation_data->rgbData[28], buf, 20);
2125+ validation_data->rgbExternalData = b64buf;
2126+ //memcpy(validation_data->rgbExternalData, buf, rc);
2127+ memcpy(&validation_data->rgbData[28], b64buf, 20);
20732128 }
20742129 }
20752130 }
@@ -2103,16 +2158,19 @@ void irStartElement(void* ctx, const xmlChar* name, const xmlChar** atts) {
21032158 validation_data->rgbData[5] = value[3];
21042159 }
21052160 if (!strcmp(type, "ExternalData")) {
2106- // TODO check buf len
2107- rc = decodeBase64(
2108- buf,
2109- (unsigned char *)value,
2110- strlen(value));
2111- // TODO check rc
2112- validation_data->ulExternalDataLength = rc;
2113- validation_data->rgbExternalData = malloc(rc);
2114- memcpy(validation_data->rgbExternalData, buf, rc);
2115- memcpy(&validation_data->rgbData[6], buf, 20);
2161+ b64buf = decodeBase64(
2162+ (char *)value,
2163+ strlen(value),
2164+ &b64buf_len);
2165+ if (b64buf == NULL) {
2166+ ERROR("decodeBase64 fail");
2167+ ir_ctx->sax_error++;
2168+ return;
2169+ }
2170+ validation_data->ulExternalDataLength = b64buf_len;
2171+ validation_data->rgbExternalData = b64buf;
2172+ //memcpy(validation_data->rgbExternalData, b64buf, rc);
2173+ memcpy(&validation_data->rgbData[6], b64buf, 20);
21162174 }
21172175 }
21182176 }
@@ -2148,14 +2206,15 @@ void irEndElement(void * ctx, const xmlChar * name) {
21482206 TSS_VALIDATION *validation_data = pctx->validation_data;
21492207 OPENPTS_PCRS *pcrs = pctx->pcrs;
21502208 int rc;
2151- BYTE buf[IR_SAX_BUFFER_SIZE];
2209+ BYTE *b64buf = NULL;
2210+ int b64buf_len;
21522211
21532212 if (!strcmp((char *)name, "stuff:Objects")) {
21542213 int extend = 0;
21552214 int pcr_index = -1;
21562215 BYTE* digest = NULL;
2157- /* Event finish, let's get into our structure */
21582216
2217+ /* Event finish, let's get into our structure */
21592218 ir_ctx->event_index++;
21602219
21612220 /* Add new event wrapper and update the chain */
@@ -2220,28 +2279,54 @@ void irEndElement(void * ctx, const xmlChar * name) {
22202279 ir_ctx->event->ulPcrIndex = atoi(ir_ctx->buf);
22212280 } else if (!strcmp((char *)name, "stuff:Hash")) {
22222281 ir_ctx->buf[ir_ctx->char_size] = 0;
2223- ir_ctx->event->rgbPcrValue = malloc(MAX_DIGEST_SIZE); // TODO(munetoh) alg -> size
2224- rc = decodeBase64(ir_ctx->event->rgbPcrValue, (unsigned char *)ir_ctx->buf, ir_ctx->char_size);
2225- ir_ctx->event->ulPcrValueLength = rc;
2282+ /* base64 -> plain */
2283+ ir_ctx->event->rgbPcrValue = decodeBase64(
2284+ (char *)ir_ctx->buf,
2285+ ir_ctx->char_size,
2286+ &b64buf_len);
2287+ if (ir_ctx->event->rgbPcrValue == NULL) {
2288+ ERROR("decodeBase64 fail");
2289+ ir_ctx->sax_error++;
2290+ return;
2291+ }
2292+ ir_ctx->event->ulPcrValueLength = b64buf_len;
22262293 } else if (!strcmp((char *)name, "eventtype")) {
22272294 ir_ctx->buf[ir_ctx->char_size] = 0;
22282295 ir_ctx->event->eventType = atoi(ir_ctx->buf);
22292296 } else if (!strcmp((char *)name, "eventdata")) {
22302297 ir_ctx->buf[ir_ctx->char_size] = 0; // null terminate
2231- /* malloc */
2232- ir_ctx->event->rgbEvent = malloc(ir_ctx->char_size + 1);
2298+ /* base64 -> plain */
2299+ ir_ctx->event->rgbEvent = decodeBase64(
2300+ (char *)ir_ctx->buf,
2301+ ir_ctx->char_size,
2302+ &b64buf_len);
22332303 if (ir_ctx->event->rgbEvent == NULL) {
2234- ERROR("no memory\n");
2304+ ERROR("decodeBase64 fail");
22352305 ir_ctx->sax_error++;
22362306 return;
22372307 }
2238- /* base64 -> plain */
2239- rc = decodeBase64(ir_ctx->event->rgbEvent, (unsigned char *)ir_ctx->buf, ir_ctx->char_size);
2240- ir_ctx->event->ulEventLength = rc;
2308+ ir_ctx->event->ulEventLength = b64buf_len;
22412309 } else if (!strcmp((char *)name, "PcrHash")) {
22422310 /* PCR value */
22432311 ir_ctx->buf[ir_ctx->char_size] = 0; // null terminate
2244- decodeBase64(ir_ctx->pcr, (unsigned char *)ir_ctx->buf, ir_ctx->char_size);
2312+ /* base64 -> plain */
2313+ b64buf = decodeBase64(
2314+ (char *)ir_ctx->buf,
2315+ ir_ctx->char_size,
2316+ &b64buf_len);
2317+ if (b64buf == NULL) {
2318+ ERROR("decodeBase64 fail");
2319+ ir_ctx->sax_error++;
2320+ return;
2321+ }
2322+ if (b64buf_len > MAX_DIGEST_SIZE) {
2323+ ERROR("decodeBase64 out is too latge, %d > %d",
2324+ b64buf_len, MAX_DIGEST_SIZE);
2325+ ir_ctx->sax_error++;
2326+ return;
2327+ }
2328+ memcpy(ir_ctx->pcr, b64buf, b64buf_len);
2329+ free(b64buf);
22452330
22462331 /* Check with PCR in TPM */
22472332 rc = checkTpmPcr2(&pctx->tpm, ir_ctx->pcr_index, ir_ctx->pcr);
@@ -2286,14 +2371,18 @@ void irEndElement(void * ctx, const xmlChar * name) {
22862371 // TODO
22872372 validation_data->rgbData[31] = atoi(ir_ctx->buf);
22882373 } else if (!strcmp((char *)name, "CompositeHash")) {
2289- // TODO
2290- rc = decodeBase64(
2291- buf,
2292- (unsigned char *)ir_ctx->buf,
2293- ir_ctx->char_size);
2294- // TODO check rc
22952374 // DEBUG("CompositeHash %s", ir_ctx->buf);
2296- memcpy(&validation_data->rgbData[32], buf, 20);
2375+ b64buf = decodeBase64(
2376+ (char *)ir_ctx->buf,
2377+ ir_ctx->char_size,
2378+ &b64buf_len);
2379+ if (b64buf == NULL) {
2380+ ERROR("decodeBase64 fail");
2381+ ir_ctx->sax_error++;
2382+ return;
2383+ }
2384+ memcpy(&validation_data->rgbData[32], b64buf, 20);
2385+ free(b64buf);
22972386 } else if (!strcmp((char *)name, "ValueSize")) {
22982387 // <ValueSize>200</ValueSize>
22992388 // Text => ctx->pcrs->value_size
@@ -2303,10 +2392,29 @@ void irEndElement(void * ctx, const xmlChar * name) {
23032392 // <PcrValue PcrNumber="0">j7/z7OqcVMjRxCz+qT1r8BvzQFs=</PcrValue>
23042393 // Text => ctx->pcrs->pcr[0]
23052394 ir_ctx->buf[ir_ctx->char_size] = 0;
2306- rc = decodeBase64(
2307- pcrs->pcr[ir_ctx->pcr_index],
2308- (unsigned char *)ir_ctx->buf,
2309- ir_ctx->char_size);
2395+ b64buf = decodeBase64(
2396+ (char *)ir_ctx->buf,
2397+ ir_ctx->char_size,
2398+ &b64buf_len);
2399+ if (b64buf == NULL) {
2400+ ERROR("decodeBase64 fail");
2401+ ir_ctx->sax_error++;
2402+ return;
2403+ }
2404+ if (b64buf_len < SHA1_DIGEST_SIZE) {
2405+ ERROR("decodeBase64 outout is too small, %d < %d", b64buf_len, SHA1_DIGEST_SIZE);
2406+ ir_ctx->sax_error++;
2407+ return;
2408+ }
2409+ if (b64buf_len > MAX_DIGEST_SIZE) {
2410+ ERROR("decodeBase64 outout is too large, %d < %d", b64buf_len, MAX_DIGEST_SIZE);
2411+ ir_ctx->sax_error++;
2412+ return;
2413+ }
2414+
2415+ memcpy(pcrs->pcr[ir_ctx->pcr_index], b64buf, b64buf_len);
2416+ free(b64buf);
2417+
23102418 pcrs->pcr_select[ir_ctx->pcr_index] = 1;
23112419
23122420 // DEBUG("PCR[%d] base64=%s\n", ir_ctx->pcr_index,ir_ctx->buf);
@@ -2321,46 +2429,52 @@ void irEndElement(void * ctx, const xmlChar * name) {
23212429 addProperty(ctx, buf2, ir_ctx->buf);
23222430 }
23232431 } else if (!strcmp((char *)name, "QuoteInfo2")) {
2324- // set pcr select
2325- // TODO
2326- validation_data->rgbData[26] = 0;
2327- validation_data->rgbData[27] = pcrs->pcr_select_size;
2328- validation_data->rgbData[28] = pcrs->pcr_select_byte[0];
2329- validation_data->rgbData[29] = pcrs->pcr_select_byte[1];
2330- validation_data->rgbData[30] = pcrs->pcr_select_byte[2];
2432+ /* pcr select => validation_data */
2433+ if (pcrs->pcr_select_byte == NULL) {
2434+ ERROR("pcrs->pcr_select_byte is null");
2435+ } else {
2436+ validation_data->rgbData[26] = 0;
2437+ validation_data->rgbData[27] = pcrs->pcr_select_size;
2438+ validation_data->rgbData[28] = pcrs->pcr_select_byte[0];
2439+ validation_data->rgbData[29] = pcrs->pcr_select_byte[1];
2440+ validation_data->rgbData[30] = pcrs->pcr_select_byte[2];
2441+ }
23312442 } else if (!strcmp((char *)name, "SignatureValue")) {
23322443 ir_ctx->buf[ir_ctx->char_size] = 0;
23332444 if (ir_ctx->char_size > IR_SAX_BUFFER_SIZE) { // TODO check buf size
23342445 ERROR("buf is small %d \n", ir_ctx->char_size);
23352446 ir_ctx->sax_error++;
23362447 } else {
2337- rc = decodeBase64(
2338- buf,
2339- (unsigned char *)ir_ctx->buf,
2340- ir_ctx->char_size);
2341- // TODO check rc
2342- validation_data->ulValidationDataLength = rc;
23432448 if (validation_data->rgbValidationData != NULL) {
23442449 free(validation_data->rgbValidationData);
23452450 }
2346- validation_data->rgbValidationData = malloc(rc);
2347- memcpy(validation_data->rgbValidationData, buf, rc);
2348- // DEBUG("rgbValidationData =%s\n",ir_ctx->buf);
2451+ /* base64 -> plain */
2452+ validation_data->rgbValidationData = decodeBase64(
2453+ (char *)ir_ctx->buf,
2454+ ir_ctx->char_size,
2455+ &b64buf_len);
2456+ if (validation_data->rgbValidationData == NULL) {
2457+ ERROR("decodeBase64 fail");
2458+ ir_ctx->sax_error++;
2459+ return;
2460+ }
2461+ validation_data->ulValidationDataLength = b64buf_len;
23492462 }
23502463 } else if (!strcmp((char *)name, "KeyValue")) {
23512464 ir_ctx->buf[ir_ctx->char_size] = 0;
23522465 if (ir_ctx->char_size > IR_SAX_BUFFER_SIZE) { // TODO check buf size
23532466 ERROR("buf is small %d \n", ir_ctx->char_size);
23542467 } else {
2355- rc = decodeBase64(
2356- buf,
2357- (unsigned char *)ir_ctx->buf,
2358- ir_ctx->char_size);
2359- // TODO check rc
2360- pcrs->pubkey_length = rc;
2361- pcrs->pubkey = malloc(rc);
2362- memcpy(pcrs->pubkey, buf, rc);
2363- // DEBUG("KeyValue %s\n", ir_ctx->buf);
2468+ pcrs->pubkey = decodeBase64(
2469+ (char *)ir_ctx->buf,
2470+ ir_ctx->char_size,
2471+ &b64buf_len);
2472+ if (pcrs->pubkey == NULL) {
2473+ ERROR("decodeBase64 fail");
2474+ ir_ctx->sax_error++;
2475+ return;
2476+ }
2477+ pcrs->pubkey_length = b64buf_len;
23642478 }
23652479 } else if (!strcmp((char *)name, "QuoteData")) {
23662480 /* check Nonce */
--- a/src/misc.c
+++ b/src/misc.c
@@ -126,7 +126,10 @@ char * snmalloc(char *str, int len) {
126126 }
127127
128128 /**
129- * get string
129+ * get NEW string buffer
130+ *
131+ * snmalloc2("ABCDEF", 2,3) => "CDE"
132+ *
130133 *
131134 * @param buf input
132135 * @param offset
@@ -375,8 +378,14 @@ char *getHexString(BYTE *bin, int size) {
375378 buf = malloc(size * 2 + 1);
376379 ptr = buf;
377380 for (i = 0; i < size; i++) {
378- len = snprintf(ptr, sizeof(ptr), "%02x", bin[i]);
379- ptr += len;
381+ //len = snprintf(ptr, sizeof(ptr), "%02x", bin[i]);
382+ len = snprintf(ptr, 3, "%02x", bin[i]);
383+ if (len != 2) {
384+ ERROR("FATAL");
385+ free(buf);
386+ return NULL;
387+ }
388+ ptr += 2; //len;
380389 }
381390
382391 return buf;
--- a/src/openpts.c
+++ b/src/openpts.c
@@ -406,7 +406,7 @@ int main(int argc, char *argv[]) {
406406 if (checkDir(target_conf_dir) == PTS_SUCCESS) {
407407 initialized++; // 1->2
408408 } else {
409- ERROR("%s is missing", target_conf_dir);
409+ ERROR("target_conf_dir, %s is missing", target_conf_dir);
410410 }
411411 }
412412
--- a/src/prop.c
+++ b/src/prop.c
@@ -249,7 +249,8 @@ int setEventProperty(OPENPTS_CONTEXT *ctx, char *name, char *value, OPENPTS_PCR_
249249
250250 if (!strcmp(value, "digest")) {
251251 /* if value = digest, base64 -> set digest as value */
252- char b64digest[SHA1_BASE64_DIGEST_SIZE+1];
252+ char *buf;
253+ int buf_len;
253254
254255 /* check */
255256 if (eventWrapper == NULL) {
@@ -257,12 +258,16 @@ int setEventProperty(OPENPTS_CONTEXT *ctx, char *name, char *value, OPENPTS_PCR_
257258 return 0; // PTS_INTERNAL_ERROR;
258259 }
259260
260- encodeBase64((unsigned char *)b64digest, (unsigned char *)eventWrapper->event->rgbPcrValue, SHA1_DIGEST_SIZE);
261- b64digest[SHA1_BASE64_DIGEST_SIZE] = 0;
262-
263- value = b64digest;
264-
265- setProperty(ctx, name, value); // TODO
261+ buf = encodeBase64(
262+ (unsigned char *)eventWrapper->event->rgbPcrValue,
263+ SHA1_DIGEST_SIZE,
264+ &buf_len);
265+ if (buf == NULL) {
266+ ERROR("encodeBase64 fail");
267+ return PTS_FATAL;
268+ }
269+ setProperty(ctx, name, buf); // TODO
270+ free(buf);
266271 } else if (!strcmp(value, "eventdata")) {
267272 TSS_PCR_EVENT *event;
268273 char * str;
--- a/src/verifier.c
+++ b/src/verifier.c
@@ -86,10 +86,12 @@ int verifierHandleCapability(
8686 OPENPTS_UUID *verifier_uuid = NULL;
8787 int rc = 0;
8888 int i;
89- char * collector_dir = NULL;
90- char * rm_dir = NULL;
9189 OPENPTS_CONFIG *target_conf = NULL;
9290 OPENPTS_CONFIG *conf = NULL;
91+ // local buffer
92+ char * collector_dir = NULL;
93+ char * rm_dir = NULL;
94+
9395
9496 /**/
9597 conf = ctx->conf;
@@ -349,9 +351,11 @@ int verifierHandleCapability(
349351 }
350352 }
351353
352- return PTS_SUCCESS;
354+ rc = PTS_SUCCESS;
353355
354356 close:
357+ if (rm_dir != NULL) free(rm_dir);
358+ if (collector_dir != NULL) free(collector_dir);
355359
356360 return rc;
357361 }
@@ -1045,7 +1049,10 @@ int enroll(
10451049 }
10461050
10471051 /* save target conf */
1048- writeTargetConf(target_conf, target_conf->uuid->uuid, target_conf->config_file); // ctx.c
1052+ writeTargetConf(
1053+ target_conf,
1054+ target_conf->uuid->uuid,
1055+ target_conf->config_file); // conf.c
10491056
10501057 /* OK */
10511058 rc = PTS_SUCCESS;
@@ -1088,8 +1095,8 @@ int verifier(
10881095 /* TLV/PTS */
10891096 PTS_IF_M_Attribute *read_tlv = NULL;
10901097 OPENPTS_CONFIG *conf;
1091- char * collector_dir = NULL;
1092- char * rm_dir = NULL;
1098+ // char * collector_dir = NULL;
1099+ // char * rm_dir = NULL;
10931100 OPENPTS_IF_M_Capability *cap;
10941101
10951102 DEBUG("verifier() - start\n");
@@ -1276,8 +1283,8 @@ int verifier(
12761283 out:
12771284 /* free */
12781285 if (read_tlv != NULL) freePtsTlv(read_tlv);
1279- if (collector_dir != NULL) free(collector_dir);
1280- if (rm_dir != NULL) free(rm_dir);
1286+ // if (collector_dir != NULL) free(collector_dir);
1287+ // if (rm_dir != NULL) free(rm_dir);
12811288 if ((rc == PTS_VERIFY_FAILED) && (mode == 1)) {
12821289 DEBUG("verifier() - update the policy");
12831290 rc = PTS_SUCCESS;
Show on old repository browser