2003-07-01 20:37:09 +00:00
|
|
|
// The contents of this file are subject to the BOINC Public License
|
2002-09-26 18:11:06 +00:00
|
|
|
// Version 1.0 (the "License"); you may not use this file except in
|
|
|
|
// compliance with the License. You may obtain a copy of the License at
|
2003-07-01 20:37:09 +00:00
|
|
|
// http://boinc.berkeley.edu/license_1.0.txt
|
2003-09-03 05:42:33 +00:00
|
|
|
//
|
2002-09-26 18:11:06 +00:00
|
|
|
// Software distributed under the License is distributed on an "AS IS"
|
|
|
|
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
|
|
|
|
// License for the specific language governing rights and limitations
|
2003-09-03 05:42:33 +00:00
|
|
|
// under the License.
|
|
|
|
//
|
|
|
|
// The Original Code is the Berkeley Open Infrastructure for Network Computing.
|
|
|
|
//
|
2002-09-26 18:11:06 +00:00
|
|
|
// The Initial Developer of the Original Code is the SETI@home project.
|
2003-07-01 20:37:09 +00:00
|
|
|
// Portions created by the SETI@home project are Copyright (C) 2002
|
2003-09-03 05:42:33 +00:00
|
|
|
// University of California at Berkeley. All Rights Reserved.
|
|
|
|
//
|
2002-09-26 18:11:06 +00:00
|
|
|
// Contributor(s):
|
|
|
|
//
|
|
|
|
|
2004-03-04 11:41:43 +00:00
|
|
|
#ifdef _WIN32
|
2004-06-16 23:16:08 +00:00
|
|
|
#include "boinc_win.h"
|
2004-03-04 11:41:43 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef _WIN32
|
2003-10-10 05:28:38 +00:00
|
|
|
#include <cctype>
|
2004-07-13 13:54:09 +00:00
|
|
|
#include <cstdio>
|
|
|
|
#include <cstdlib>
|
2002-07-16 19:31:37 +00:00
|
|
|
#if HAVE_MALLOC_H
|
2002-06-14 05:49:34 +00:00
|
|
|
#include <malloc.h>
|
2002-07-16 19:31:37 +00:00
|
|
|
#endif
|
2004-03-04 11:41:43 +00:00
|
|
|
#endif
|
2002-06-14 05:49:34 +00:00
|
|
|
|
|
|
|
#include "md5_file.h"
|
2002-07-11 01:09:53 +00:00
|
|
|
#include "error_numbers.h"
|
2002-06-14 05:49:34 +00:00
|
|
|
|
2002-08-30 20:56:02 +00:00
|
|
|
#include "crypt.h"
|
|
|
|
|
2004-07-03 21:38:15 +00:00
|
|
|
#ifdef _USING_FCGI_
|
|
|
|
#include "fcgi_stdio.h"
|
|
|
|
#endif
|
|
|
|
|
2002-07-09 00:10:58 +00:00
|
|
|
// NOTE: the fast CGI I/O library doesn't have fscanf(),
|
|
|
|
// so some of the following have been modified to use
|
|
|
|
// fgets() and sscanf() instead
|
|
|
|
|
2002-07-05 05:33:40 +00:00
|
|
|
// write some data in hex notation.
|
2002-06-14 05:49:34 +00:00
|
|
|
// NOTE: since length may not be known to the reader,
|
|
|
|
// we follow the data with a non-hex character '.'
|
|
|
|
//
|
|
|
|
int print_hex_data(FILE* f, DATA_BLOCK& x) {
|
2002-07-11 01:09:53 +00:00
|
|
|
unsigned int i;
|
2002-08-30 20:56:02 +00:00
|
|
|
|
2002-06-14 05:49:34 +00:00
|
|
|
for (i=0; i<x.len; i++) {
|
|
|
|
fprintf(f, "%02x", x.data[i]);
|
|
|
|
if (i%32==31) fprintf(f, "\n");
|
|
|
|
}
|
|
|
|
if (x.len%32 != 0) fprintf(f, "\n");
|
|
|
|
fprintf(f, ".\n");
|
2002-07-11 01:09:53 +00:00
|
|
|
return 0;
|
2002-06-14 05:49:34 +00:00
|
|
|
}
|
|
|
|
|
2002-07-05 05:33:40 +00:00
|
|
|
// same, but write to buffer
|
|
|
|
//
|
|
|
|
int sprint_hex_data(char* p, DATA_BLOCK& x) {
|
2002-07-11 01:09:53 +00:00
|
|
|
unsigned int i;
|
2002-07-05 05:33:40 +00:00
|
|
|
char buf[16];
|
2002-08-30 20:56:02 +00:00
|
|
|
|
2002-07-05 05:33:40 +00:00
|
|
|
strcpy(p, "");
|
|
|
|
for (i=0; i<x.len; i++) {
|
|
|
|
sprintf(buf, "%02x", x.data[i]);
|
|
|
|
strcat(p, buf);
|
|
|
|
if (i%32==31) strcat(p, "\n");
|
|
|
|
}
|
|
|
|
if (x.len%32 != 0) strcat(p, "\n");
|
|
|
|
strcat(p, ".\n");
|
2002-07-16 19:31:37 +00:00
|
|
|
|
2002-07-11 01:09:53 +00:00
|
|
|
return 0;
|
2002-07-05 05:33:40 +00:00
|
|
|
}
|
|
|
|
|
2002-06-14 05:49:34 +00:00
|
|
|
// scan data in hex notation.
|
|
|
|
// stop when you reach a non-parsed character.
|
2002-07-09 00:10:58 +00:00
|
|
|
// NOTE: buffer must be big enough; no checking is done.
|
2002-06-14 05:49:34 +00:00
|
|
|
//
|
|
|
|
int scan_hex_data(FILE* f, DATA_BLOCK& x) {
|
|
|
|
int n;
|
2002-08-30 20:56:02 +00:00
|
|
|
|
2002-06-14 05:49:34 +00:00
|
|
|
x.len = 0;
|
2002-07-09 00:10:58 +00:00
|
|
|
#if _USING_FCGI_
|
|
|
|
char *p, buf[256];
|
2002-07-11 01:09:53 +00:00
|
|
|
int i, j;
|
2002-07-09 00:10:58 +00:00
|
|
|
while (1) {
|
|
|
|
p = fgets(buf, 256, f);
|
2003-10-21 04:06:55 +00:00
|
|
|
if (!p) return ERR_GETS;
|
2002-07-09 00:10:58 +00:00
|
|
|
n = strlen(p)/2;
|
|
|
|
if (n == 0) break;
|
|
|
|
for (i=0; i<n; i++) {
|
|
|
|
sscanf(buf+i*2, "%2x", &j);
|
|
|
|
x.data[x.len] = j;
|
|
|
|
x.len++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
2002-06-14 05:49:34 +00:00
|
|
|
while (1) {
|
2003-06-17 20:18:56 +00:00
|
|
|
int j;
|
|
|
|
n = fscanf(f, "%2x", &j);
|
2002-07-09 00:10:58 +00:00
|
|
|
if (n <= 0) break;
|
2003-06-17 20:18:56 +00:00
|
|
|
x.data[x.len] = j;
|
2002-06-14 05:49:34 +00:00
|
|
|
x.len++;
|
|
|
|
}
|
2002-07-09 00:10:58 +00:00
|
|
|
#endif
|
2002-06-14 05:49:34 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-07-05 05:33:40 +00:00
|
|
|
// same, but read from buffer
|
|
|
|
//
|
2003-09-03 23:54:11 +00:00
|
|
|
static int sscan_hex_data(char* p, DATA_BLOCK& x) {
|
2002-07-07 20:39:24 +00:00
|
|
|
int m, n, nleft=x.len;
|
2002-08-30 20:56:02 +00:00
|
|
|
|
2002-07-05 05:33:40 +00:00
|
|
|
x.len = 0;
|
|
|
|
while (1) {
|
2003-10-10 05:28:38 +00:00
|
|
|
if (isspace(*p)) {
|
|
|
|
++p;
|
|
|
|
continue;
|
|
|
|
}
|
2002-07-07 20:39:24 +00:00
|
|
|
n = sscanf(p, "%2x", &m);
|
2002-07-05 05:33:40 +00:00
|
|
|
if (n <= 0) break;
|
2002-07-07 20:39:24 +00:00
|
|
|
x.data[x.len++] = m;
|
|
|
|
nleft--;
|
|
|
|
if (nleft<0) {
|
|
|
|
fprintf(stderr, "sscan_hex_data: buffer overflow\n");
|
2003-09-03 23:54:11 +00:00
|
|
|
return ERR_BAD_HEX_FORMAT;
|
2002-07-07 20:39:24 +00:00
|
|
|
}
|
2002-07-05 05:33:40 +00:00
|
|
|
p += 2;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-06-14 05:49:34 +00:00
|
|
|
// print a key in ASCII form
|
|
|
|
//
|
|
|
|
int print_key_hex(FILE* f, KEY* key, int size) {
|
2002-07-11 01:09:53 +00:00
|
|
|
int len;
|
2002-06-14 05:49:34 +00:00
|
|
|
DATA_BLOCK x;
|
2002-08-30 20:56:02 +00:00
|
|
|
|
2002-06-14 05:49:34 +00:00
|
|
|
fprintf(f, "%d\n", key->bits);
|
|
|
|
len = size - sizeof(key->bits);
|
|
|
|
x.data = key->data;
|
|
|
|
x.len = len;
|
|
|
|
return print_hex_data(f, x);
|
|
|
|
}
|
|
|
|
|
|
|
|
int scan_key_hex(FILE* f, KEY* key, int size) {
|
2002-07-05 05:33:40 +00:00
|
|
|
int len, i, n;
|
2002-07-09 00:10:58 +00:00
|
|
|
int num_bits;
|
2002-08-30 20:56:02 +00:00
|
|
|
|
2002-07-09 00:10:58 +00:00
|
|
|
#if _USING_FCGI_
|
2002-07-11 01:09:53 +00:00
|
|
|
#if 0
|
|
|
|
char *p, buf[256];
|
2002-07-09 00:10:58 +00:00
|
|
|
int j = 0, b;
|
|
|
|
fgets(buf, 256, f);
|
2002-07-05 22:02:01 +00:00
|
|
|
sscanf(buf, "%d", &num_bits);
|
|
|
|
key->bits = num_bits;
|
2002-06-14 05:49:34 +00:00
|
|
|
len = size - sizeof(key->bits);
|
2002-07-09 00:10:58 +00:00
|
|
|
while (1) {
|
|
|
|
p = fgets(buf, 256, f);
|
2003-10-21 04:06:55 +00:00
|
|
|
if (!p) return ERR_GETS;
|
2002-07-09 00:10:58 +00:00
|
|
|
n = strlen(p)/2;
|
|
|
|
if (n == 0) break;
|
|
|
|
for (i=0; i<n; i++) {
|
|
|
|
sscanf(buf+i*2, "%2x", &b);
|
2003-10-21 04:06:55 +00:00
|
|
|
if (j >= len) return ERR_SCANF;
|
2002-07-09 00:10:58 +00:00
|
|
|
key->data[j++] = b;
|
2002-07-05 22:02:01 +00:00
|
|
|
}
|
2002-06-14 05:49:34 +00:00
|
|
|
}
|
2002-07-05 22:02:01 +00:00
|
|
|
fgets(buf, size, f);
|
2002-07-05 19:20:00 +00:00
|
|
|
sscanf(buf, ".");
|
2002-07-11 01:09:53 +00:00
|
|
|
#endif
|
2002-07-09 00:10:58 +00:00
|
|
|
#else
|
|
|
|
fscanf(f, "%d", &num_bits);
|
|
|
|
key->bits = num_bits;
|
|
|
|
len = size - sizeof(key->bits);
|
|
|
|
for (i=0; i<len; i++) {
|
|
|
|
fscanf(f, "%2x", &n);
|
|
|
|
key->data[i] = n;
|
|
|
|
}
|
|
|
|
fscanf(f, ".");
|
|
|
|
#endif
|
2002-06-14 05:49:34 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-07-07 20:39:24 +00:00
|
|
|
// parse a text-encoded key from a memory buffer
|
|
|
|
//
|
|
|
|
int sscan_key_hex(char* buf, KEY* key, int size) {
|
2002-07-11 01:09:53 +00:00
|
|
|
int n, retval,num_bits;
|
2002-07-07 20:39:24 +00:00
|
|
|
DATA_BLOCK db;
|
2002-07-16 19:31:37 +00:00
|
|
|
|
2002-07-11 01:09:53 +00:00
|
|
|
//fprintf(stderr, "buf = %s\n", buf);
|
|
|
|
n = sscanf(buf, "%d", &num_bits);
|
|
|
|
key->bits = num_bits; //key->bits is a short
|
|
|
|
//fprintf(stderr, "key->bits = %d\n", key->bits);
|
2002-07-16 19:31:37 +00:00
|
|
|
|
2003-10-21 04:06:55 +00:00
|
|
|
if (n != 1) return ERR_SCANF;
|
2002-07-07 20:39:24 +00:00
|
|
|
buf = strchr(buf, '\n');
|
2003-10-21 04:06:55 +00:00
|
|
|
if (!buf) return ERR_STRCHR;
|
2002-07-07 20:39:24 +00:00
|
|
|
buf += 1;
|
|
|
|
db.data = key->data;
|
2002-07-11 01:09:53 +00:00
|
|
|
db.len = size - sizeof(key->bits); //huh???
|
2002-07-07 20:39:24 +00:00
|
|
|
retval = sscan_hex_data(buf, db);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2002-06-14 05:49:34 +00:00
|
|
|
// encrypt some data.
|
|
|
|
// The amount encrypted may be less than what's supplied.
|
|
|
|
// The output buffer must be at least MIN_OUT_BUFFER_SIZE.
|
|
|
|
// The output block must be decrypted in its entirety.
|
|
|
|
//
|
|
|
|
int encrypt_private(
|
|
|
|
R_RSA_PRIVATE_KEY& key, DATA_BLOCK& in, DATA_BLOCK& out,
|
|
|
|
int& nbytes_encrypted
|
|
|
|
) {
|
2002-07-05 05:33:40 +00:00
|
|
|
int retval, n, modulus_len;
|
2002-08-30 20:56:02 +00:00
|
|
|
|
2002-07-05 05:33:40 +00:00
|
|
|
modulus_len = (key.bits+7)/8;
|
2002-06-14 05:49:34 +00:00
|
|
|
n = in.len;
|
2002-07-05 05:33:40 +00:00
|
|
|
if (n >= modulus_len-11) {
|
|
|
|
n = modulus_len-11;
|
2002-06-14 05:49:34 +00:00
|
|
|
}
|
|
|
|
retval = RSAPrivateEncrypt(out.data, &out.len, in.data, n, &key);
|
2002-07-05 05:33:40 +00:00
|
|
|
if (retval ) return retval;
|
|
|
|
nbytes_encrypted = retval;
|
2002-06-14 05:49:34 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int decrypt_public(R_RSA_PUBLIC_KEY& key, DATA_BLOCK& in, DATA_BLOCK& out) {
|
2002-07-05 19:20:00 +00:00
|
|
|
return RSAPublicDecrypt(out.data, &out.len, in.data, in.len, &key);
|
2002-06-14 05:49:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int sign_file(char* path, R_RSA_PRIVATE_KEY& key, DATA_BLOCK& signature) {
|
2002-07-05 05:33:40 +00:00
|
|
|
char md5_buf[MD5_LEN];
|
2002-06-14 05:49:34 +00:00
|
|
|
double file_length;
|
|
|
|
DATA_BLOCK in_block;
|
|
|
|
int retval, n;
|
2002-08-30 20:56:02 +00:00
|
|
|
|
2002-06-14 05:49:34 +00:00
|
|
|
retval = md5_file(path, md5_buf, file_length);
|
|
|
|
if (retval) return retval;
|
|
|
|
in_block.data = (unsigned char*)md5_buf;
|
|
|
|
in_block.len = strlen(md5_buf);
|
|
|
|
retval = encrypt_private(key, in_block, signature, n);
|
|
|
|
if (retval) return retval;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-07-05 05:33:40 +00:00
|
|
|
int sign_block(DATA_BLOCK& data_block, R_RSA_PRIVATE_KEY& key, DATA_BLOCK& signature) {
|
|
|
|
char md5_buf[MD5_LEN];
|
|
|
|
int retval, n;
|
|
|
|
DATA_BLOCK in_block;
|
|
|
|
|
|
|
|
md5_block(data_block.data, data_block.len, md5_buf);
|
|
|
|
in_block.data = (unsigned char*)md5_buf;
|
|
|
|
in_block.len = strlen(md5_buf);
|
|
|
|
retval = encrypt_private(key, in_block, signature, n);
|
|
|
|
if (retval) {
|
|
|
|
printf("sign_block: encrypt_private returned %d\n", retval);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-06-14 05:49:34 +00:00
|
|
|
int verify_file(
|
|
|
|
char* path, R_RSA_PUBLIC_KEY& key, DATA_BLOCK& signature, bool& answer
|
|
|
|
) {
|
2002-07-07 20:39:24 +00:00
|
|
|
char md5_buf[MD5_LEN], clear_buf[MD5_LEN];
|
2002-06-14 05:49:34 +00:00
|
|
|
double file_length;
|
|
|
|
int n, retval;
|
|
|
|
DATA_BLOCK clear_signature;
|
2002-08-30 20:56:02 +00:00
|
|
|
|
2002-06-14 05:49:34 +00:00
|
|
|
retval = md5_file(path, md5_buf, file_length);
|
2002-07-11 01:09:53 +00:00
|
|
|
if (retval) {
|
|
|
|
fprintf(stderr, "error: verify_file: md5_file error %d\n", retval);
|
|
|
|
return retval;
|
|
|
|
}
|
2002-06-14 05:49:34 +00:00
|
|
|
n = strlen(md5_buf);
|
|
|
|
clear_signature.data = (unsigned char*)clear_buf;
|
2002-07-07 20:39:24 +00:00
|
|
|
clear_signature.len = MD5_LEN;
|
2002-06-14 05:49:34 +00:00
|
|
|
retval = decrypt_public(key, signature, clear_signature);
|
2002-07-11 01:09:53 +00:00
|
|
|
if (retval) {
|
|
|
|
fprintf(stderr, "error: verify_file: decrypt_public error %d\n", retval);
|
|
|
|
return retval;
|
|
|
|
}
|
2002-06-14 05:49:34 +00:00
|
|
|
answer = !strncmp(md5_buf, clear_buf, n);
|
|
|
|
return 0;
|
|
|
|
}
|
2002-07-05 05:33:40 +00:00
|
|
|
|
2002-07-07 20:39:24 +00:00
|
|
|
int verify_file2(
|
|
|
|
char* path, char* signature_text, char* key_text, bool& answer
|
|
|
|
) {
|
|
|
|
R_RSA_PUBLIC_KEY key;
|
|
|
|
unsigned char signature_buf[SIGNATURE_SIZE_BINARY];
|
|
|
|
int retval;
|
|
|
|
DATA_BLOCK signature;
|
2002-08-30 20:56:02 +00:00
|
|
|
|
2002-07-07 20:39:24 +00:00
|
|
|
retval = sscan_key_hex(key_text, (KEY*)&key, sizeof(key));
|
2002-07-11 01:09:53 +00:00
|
|
|
if (retval) {
|
|
|
|
fprintf(stderr, "error: verify_file2: sscan_key_hex did not work\n");
|
|
|
|
return retval;
|
|
|
|
}
|
2002-07-07 20:39:24 +00:00
|
|
|
signature.data = signature_buf;
|
|
|
|
signature.len = sizeof(signature_buf);
|
2003-09-03 23:54:11 +00:00
|
|
|
retval = sscan_hex_data(signature_text, signature);
|
|
|
|
if (retval) return retval;
|
2002-07-07 20:39:24 +00:00
|
|
|
return verify_file(path, key, signature, answer);
|
|
|
|
}
|
|
|
|
|
2002-07-05 05:33:40 +00:00
|
|
|
// verify, where both text and signature are char strings
|
|
|
|
//
|
|
|
|
int verify_string(
|
|
|
|
char* text, char* signature_text, R_RSA_PUBLIC_KEY& key, bool& answer
|
|
|
|
) {
|
|
|
|
char md5_buf[MD5_LEN];
|
2002-07-07 20:39:24 +00:00
|
|
|
unsigned char signature_buf[SIGNATURE_SIZE_BINARY];
|
2002-07-05 05:33:40 +00:00
|
|
|
char clear_buf[MD5_LEN];
|
|
|
|
int retval, n;
|
|
|
|
DATA_BLOCK signature, clear_signature;
|
2002-08-30 20:56:02 +00:00
|
|
|
|
2002-07-05 05:33:40 +00:00
|
|
|
retval = md5_block((unsigned char*)text, strlen(text), md5_buf);
|
|
|
|
if (retval) return retval;
|
|
|
|
n = strlen(md5_buf);
|
|
|
|
signature.data = signature_buf;
|
2002-07-07 20:39:24 +00:00
|
|
|
signature.len = sizeof(signature_buf);
|
2003-09-03 23:54:11 +00:00
|
|
|
retval = sscan_hex_data(signature_text, signature);
|
|
|
|
if (retval) return retval;
|
2002-07-05 05:33:40 +00:00
|
|
|
clear_signature.data = (unsigned char*)clear_buf;
|
|
|
|
clear_signature.len = 256;
|
|
|
|
retval = decrypt_public(key, signature, clear_signature);
|
|
|
|
if (retval) return retval;
|
|
|
|
answer = !strncmp(md5_buf, clear_buf, n);
|
|
|
|
return 0;
|
|
|
|
}
|
2002-07-07 20:39:24 +00:00
|
|
|
|
|
|
|
// Same, where public key is also encoded as text
|
|
|
|
//
|
|
|
|
int verify_string2(
|
|
|
|
char* text, char* signature_text, char* key_text, bool& answer
|
|
|
|
) {
|
|
|
|
R_RSA_PUBLIC_KEY key;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
retval = sscan_key_hex(key_text, (KEY*)&key, sizeof(key));
|
|
|
|
if (retval) return retval;
|
|
|
|
return verify_string(text, signature_text, key, answer);
|
|
|
|
}
|
2003-09-03 05:42:33 +00:00
|
|
|
|
|
|
|
int read_key_file(char* keyfile, R_RSA_PRIVATE_KEY& key) {
|
|
|
|
int retval;
|
|
|
|
FILE* fkey = fopen(keyfile, "r");
|
|
|
|
if (!fkey) {
|
|
|
|
fprintf(stderr, "can't open key file (%s)\n", keyfile);
|
2003-10-21 04:06:55 +00:00
|
|
|
return ERR_FOPEN;
|
2003-09-03 05:42:33 +00:00
|
|
|
}
|
|
|
|
retval = scan_key_hex(fkey, (KEY*)&key, sizeof(key));
|
|
|
|
fclose(fkey);
|
|
|
|
if (retval) {
|
|
|
|
fprintf(stderr, "can't parse key\n");
|
2003-10-21 04:06:55 +00:00
|
|
|
return retval;
|
2003-09-03 05:42:33 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|