misc/piggyback/piggyback.c

/*
 * piggyback.c (c) 2005 by Torben H. Nielsen <torben@t-hoerup.dk>
 *
 * requires openssl-dev
 * compile with gcc -o piggyback -l crypto piggyback.c
 *   (perhaps with -O3)
 *
 * return values:
 *    0: success
 *    1: could not open file
 *    2: md5 mismatch
 */

/*****************************************************************
 * ToDo:
 *  V At detach, remove() outfile if data md5 mismatch is detected
 *  V detach - read options field
 *  - ReWrite commandline args handling
 *  - Compression
 *  - Encryption/Decryption
 */
 
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <openssl/md5.h>
#include <sys/stat.h>

#include "gzcompress.h"

#define CHUNK_SIZE 512


void printusage( void ) {
        
        printf("piggyback by hoerup\n");
        printf("Usage: piggyback [options] attach <carrier-file> <payload-file> <output-file>\n");
        printf("       piggyback detach <carrier-file> <output-file>\n\n");
        printf("Options:\n");
        printf("     --compress:    use gzcompression on payload data\n");
        printf("\n");
        
        exit(0);
}

int main(int argc, char *argv[]) {
        FILE *carrierfile, *payloadfile, *outfile;
        int carrieridx;
        
        unsigned char buf[CHUNK_SIZE];
        unsigned char md5sum[16];
        unsigned char md5string[33];
        unsigned char options[8];
        unsigned char tmpstr[40];
        unsigned char header[80];
        
        char *ptr;
        int num, bytes_extracted;
        int pointer, headerpointer;
        int i;
        MD5_CTX md5;
        
        if(  !( (argc ==4  && strcmp(argv[1],"attach") ) || (argc == 5 && strcmp(argv[1],"detach")) ) ) {
                printusage();
        }
        carrieridx = 2;
        
        //create output-file with 644 permissions
        umask(022);

        if ( strcmp(argv[1], "attach")==0 ) { //attach
                carrierfile = fopen(argv[carrieridx], "r");
                payloadfile = fopen(argv[carrieridx+1], "r");
                outfile = fopen(argv[carrieridx+2], "w");

                if (carrierfile == 0) {
                        printf("Could not open carrier file (%s) for reading\n", argv[carrieridx]);
                        return 1;
                }
                if (payloadfile == 0) {
                        printf("Could not open payload file (%s) for reading\n", argv[carrieridx+1]);
                        return 1;
                }
                if (outfile == 0) {
                        printf("Could not open output file (%s) for writing\n", argv[carrieridx+2]);
                        return 1;
                }
                
                for (i=0;i<8;i++)
                        options[i] = 0;

                pointer=0;
                while (!feof(carrierfile)) {
                        num = fread(buf, 1, CHUNK_SIZE, carrierfile);
                        fwrite(buf, 1, num, outfile);
                        pointer += num;
                }

                MD5_Init(&md5);

                while (!feof(payloadfile)) {
                        num = fread(buf, 1, CHUNK_SIZE, payloadfile);
                        fwrite(buf, 1, num, outfile);
                        MD5_Update(&md5, buf, num);
                }

                MD5_Final(md5sum, &md5);

                for (i=0; i<16; i++) 
                        fprintf(outfile, "%02x", md5sum[i]);

                sprintf(header, "%08x", pointer);

                for (i=0; i<8; i++) {
                        sprintf(tmpstr, "%c", options[i]+48); //ascii(48)='0'
                        strcat(header, tmpstr);
                }


                fprintf(outfile, header, 16);
                
                MD5_Init(&md5);         
                MD5_Update(&md5, header, 16);
                MD5_Final(md5sum, &md5);

                for (i=0; i<16; i++)
                        fprintf(outfile, "%02x", md5sum[i]);

                fclose(carrierfile);
                fclose(payloadfile);
                fclose(outfile);
                
        } else { //detach
                carrierfile = fopen(argv[carrieridx], "r");
                outfile = fopen(argv[carrieridx+1], "w");


                if (carrierfile == 0) {
                        printf("Could not open carrier file (%s) for reading\n", argv[carrieridx]);
                        return 1;
                }

                if (outfile == 0) {
                        printf("Could not open output file (%s) for writing\n", argv[carrieridx+1]);
                        return 1;
                }
                //header size is 80 bytes
                fseek(carrierfile, -80, SEEK_END);
                headerpointer = ftell(carrierfile);
                fread(header, 1, 80, carrierfile);
                
                ptr = header + 32;
                strncpy(tmpstr, ptr, 16); 
                
                MD5_Init(&md5);
                MD5_Update(&md5, tmpstr, 16);
                MD5_Final(md5sum, &md5);
                md5string[0] = 0;

                for (i=0; i<16;i++) {
                        sprintf(tmpstr, "%02x", md5sum[i]);
                        strcat(md5string, tmpstr);
                }

                ptr += 16;
                strncpy(tmpstr, ptr, 32);
                tmpstr[32] = 0;
                
                if (strncmp(md5string, tmpstr, 32) != 0) {
                        printf("Header MD5 checksum mismatch!\n");
                        return 2;
                }

                // Read data-pointer
                ptr = header + 32;
                strncpy(tmpstr, ptr, 8);

                tmpstr[8] = 0; //make tmpstr a 0-terminated string

                pointer = strtol(tmpstr, (char **)NULL, 16);
                
                // Read Options fields
                ptr += 8;
                strncpy(options, ptr, 8);
                for (i=0; i<8; i++)
                        options[i] -= 48;

                bytes_extracted = 0;
                fseek(carrierfile, pointer, SEEK_SET);
                MD5_Init( &md5 );
                num=CHUNK_SIZE;
                while ( num == CHUNK_SIZE)  {
                        num = headerpointer -  pointer;
                        num -= bytes_extracted;
                        
                        if ( num >= CHUNK_SIZE )
                                num = CHUNK_SIZE;
                        
                        fread(buf, 1 , num, carrierfile);
                        fwrite(buf, 1,  num, outfile);
                        MD5_Update( &md5, buf, num);
                        bytes_extracted += num;
                }
                
                fclose(carrierfile);
                fclose(outfile);
                
                MD5_Final(md5sum, &md5);
                md5string[0] = 0;

                for (i=0; i<16; i++) {
                        sprintf(tmpstr, "%02x", md5sum[i]);
                        strcat( md5string, tmpstr);
                }
                
                strncpy(tmpstr, header, 32);
                tmpstr[32] = 0;
                if (strncmp(md5string, tmpstr, 32) !=0) {
                        printf("Payload MD5 checksum mismatch!\n");
                        remove( argv[carrieridx+1] );
                        return 2;
                }
        }
        
        
        return 0;
}
1	torben	328	/*
2			* piggyback.c (c) 2005 by Torben H. Nielsen <torben@t-hoerup.dk>
3			*
4			* requires openssl-dev
5			* compile with gcc -o piggyback -l crypto piggyback.c
6			* (perhaps with -O3)
7			*
8			* return values:
9			* 0: success
10			* 1: could not open file
11			* 2: md5 mismatch
12			*/
13
14			/*****************************************************************
15			* ToDo:
16			* V At detach, remove() outfile if data md5 mismatch is detected
17			* V detach - read options field
18			* - ReWrite commandline args handling
19			* - Compression
20			* - Encryption/Decryption
21			*/
22
23
24			#include <stdlib.h>
25			#include <stdio.h>
26			#include <string.h>
27			#include <openssl/md5.h>
28			#include <sys/stat.h>
29
30			#include "gzcompress.h"
31
32			#define CHUNK_SIZE 512
33
34
35			void printusage( void ) {
36
37			printf("piggyback by hoerup\n");
38			printf("Usage: piggyback [options] attach <carrier-file> <payload-file> <output-file>\n");
39			printf(" piggyback detach <carrier-file> <output-file>\n\n");
40			printf("Options:\n");
41			printf(" --compress: use gzcompression on payload data\n");
42			printf("\n");
43
44			exit(0);
45			}
46
47			int main(int argc, char *argv[]) {
48			FILE carrierfile, payloadfile, *outfile;
49			int carrieridx;
50
51			unsigned char buf[CHUNK_SIZE];
52			unsigned char md5sum[16];
53			unsigned char md5string[33];
54			unsigned char options[8];
55			unsigned char tmpstr[40];
56			unsigned char header[80];
57
58			char *ptr;
59			int num, bytes_extracted;
60			int pointer, headerpointer;
61			int i;
62			MD5_CTX md5;
63
64			if( !( (argc ==4 && strcmp(argv[1],"attach") ) \|\| (argc == 5 && strcmp(argv[1],"detach")) ) ) {
65			printusage();
66			}
67			carrieridx = 2;
68
69			//create output-file with 644 permissions
70			umask(022);
71
72			if ( strcmp(argv[1], "attach")==0 ) { //attach
73			carrierfile = fopen(argv[carrieridx], "r");
74			payloadfile = fopen(argv[carrieridx+1], "r");
75			outfile = fopen(argv[carrieridx+2], "w");
76
77			if (carrierfile == 0) {
78			printf("Could not open carrier file (%s) for reading\n", argv[carrieridx]);
79			return 1;
80			}
81			if (payloadfile == 0) {
82			printf("Could not open payload file (%s) for reading\n", argv[carrieridx+1]);
83			return 1;
84			}
85			if (outfile == 0) {
86			printf("Could not open output file (%s) for writing\n", argv[carrieridx+2]);
87			return 1;
88			}
89
90			for (i=0;i<8;i++)
91			options[i] = 0;
92
93			pointer=0;
94			while (!feof(carrierfile)) {
95			num = fread(buf, 1, CHUNK_SIZE, carrierfile);
96			fwrite(buf, 1, num, outfile);
97			pointer += num;
98			}
99
100			MD5_Init(&md5);
101
102			while (!feof(payloadfile)) {
103			num = fread(buf, 1, CHUNK_SIZE, payloadfile);
104			fwrite(buf, 1, num, outfile);
105			MD5_Update(&md5, buf, num);
106			}
107
108			MD5_Final(md5sum, &md5);
109
110			for (i=0; i<16; i++)
111			fprintf(outfile, "%02x", md5sum[i]);
112
113			sprintf(header, "%08x", pointer);
114
115			for (i=0; i<8; i++) {
116			sprintf(tmpstr, "%c", options[i]+48); //ascii(48)='0'
117			strcat(header, tmpstr);
118			}
119
120
121			fprintf(outfile, header, 16);
122
123			MD5_Init(&md5);
124			MD5_Update(&md5, header, 16);
125			MD5_Final(md5sum, &md5);
126
127			for (i=0; i<16; i++)
128			fprintf(outfile, "%02x", md5sum[i]);
129
130			fclose(carrierfile);
131			fclose(payloadfile);
132			fclose(outfile);
133
134			} else { //detach
135			carrierfile = fopen(argv[carrieridx], "r");
136			outfile = fopen(argv[carrieridx+1], "w");
137
138
139			if (carrierfile == 0) {
140			printf("Could not open carrier file (%s) for reading\n", argv[carrieridx]);
141			return 1;
142			}
143
144			if (outfile == 0) {
145			printf("Could not open output file (%s) for writing\n", argv[carrieridx+1]);
146			return 1;
147			}
148			//header size is 80 bytes
149			fseek(carrierfile, -80, SEEK_END);
150			headerpointer = ftell(carrierfile);
151			fread(header, 1, 80, carrierfile);
152
153			ptr = header + 32;
154			strncpy(tmpstr, ptr, 16);
155
156			MD5_Init(&md5);
157			MD5_Update(&md5, tmpstr, 16);
158			MD5_Final(md5sum, &md5);
159			md5string[0] = 0;
160
161			for (i=0; i<16;i++) {
162			sprintf(tmpstr, "%02x", md5sum[i]);
163			strcat(md5string, tmpstr);
164			}
165
166			ptr += 16;
167			strncpy(tmpstr, ptr, 32);
168			tmpstr[32] = 0;
169
170			if (strncmp(md5string, tmpstr, 32) != 0) {
171			printf("Header MD5 checksum mismatch!\n");
172			return 2;
173			}
174
175			// Read data-pointer
176			ptr = header + 32;
177			strncpy(tmpstr, ptr, 8);
178
179			tmpstr[8] = 0; //make tmpstr a 0-terminated string
180
181			pointer = strtol(tmpstr, (char **)NULL, 16);
182
183			// Read Options fields
184			ptr += 8;
185			strncpy(options, ptr, 8);
186			for (i=0; i<8; i++)
187			options[i] -= 48;
188
189			bytes_extracted = 0;
190			fseek(carrierfile, pointer, SEEK_SET);
191			MD5_Init( &md5 );
192			num=CHUNK_SIZE;
193			while ( num == CHUNK_SIZE) {
194			num = headerpointer - pointer;
195			num -= bytes_extracted;
196
197			if ( num >= CHUNK_SIZE )
198			num = CHUNK_SIZE;
199
200			fread(buf, 1 , num, carrierfile);
201			fwrite(buf, 1, num, outfile);
202			MD5_Update( &md5, buf, num);
203			bytes_extracted += num;
204			}
205
206			fclose(carrierfile);
207			fclose(outfile);
208
209			MD5_Final(md5sum, &md5);
210			md5string[0] = 0;
211
212			for (i=0; i<16; i++) {
213			sprintf(tmpstr, "%02x", md5sum[i]);
214			strcat( md5string, tmpstr);
215			}
216
217			strncpy(tmpstr, header, 32);
218			tmpstr[32] = 0;
219			if (strncmp(md5string, tmpstr, 32) !=0) {
220			printf("Payload MD5 checksum mismatch!\n");
221			remove( argv[carrieridx+1] );
222			return 2;
223			}
224			}
225
226
227			return 0;
228			}