Rev

Rev 2398 | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | SVN | Bug Tracker

Rev 2398 Rev 2655
Line 18... Line 18...
18
#include <openssl/ecdsa.h>
18
#include <openssl/ecdsa.h>
19
#include <string.h>
19
#include <string.h>
20
20
21
#include "../cshared/cstr.h"
21
#include "../cshared/cstr.h"
22
#include "../cshared/cserialize.h"
22
#include "../cshared/cserialize.h"
-
 
23
#include "../cshared/copts.h"
23
24
24
static size_t   load_certificate(const char * path, char ** p);
25
static size_t   load_certificate(const char * path, char ** p);
25
static EC_KEY * load_public_key(const char* path, const EC_GROUP * group);
26
static EC_KEY * load_public_key(const char* path, const EC_GROUP * group);
26
static EC_KEY * get_verification_key(const char* buf, size_t len, const EC_GROUP * group);
27
static EC_KEY * get_verification_key(const char* buf, size_t len, const EC_GROUP * group);
27
static void     calculate_certificate_digest(const char* data, int length, char * hash);
28
static void     calculate_certificate_digest(const char* data, int length, char * hash);
Line 126... Line 127...
126
        "certificate",
127
        "certificate",
127
        "chain",
128
        "chain",
128
        "other",
129
        "other",
129
};
130
};
130
131
-
 
132
static void usage(){
-
 
133
        printf("Usage: msgcheck [Options] messages\n"
-
 
134
                "Options:\n"
-
 
135
                "  -c <certificate> Use this certificate instead of the one from message\n"
-
 
136
                "  -k <public key>  Use the public key from given file\n"
-
 
137
                "  -r               Reset. Use keys from messages\n"
-
 
138
                "  -E               Use canonical encoding (compatible with TS103097 v1.2.1 and early\n");
-
 
139
}
-
 
140
-
 
141
static int _canonicalEncoding = 0;
131
int main(int argc, char ** argv)
142
int main(int argc, char ** argv)
132
{
143
{
133
        int i;
144
        int i;
134
        EC_KEY * defkey = NULL;
145
        EC_KEY * defkey = NULL;
135
        EC_GROUP * group;
146
        EC_GROUP * group;
136
        char cert_digest[8] = { 0 };
147
        char cert_digest[8] = { 0 };
137
148
138
        if (argc < 2 || 0 == strcmp("-h", argv[1])){
149
        if (argc < 2 || 0 == strcmp("-h", argv[1])){
139
                printf("Usage: msgcheck [-c certificate] [-p pub key] messages\n");
150
                usage();
140
                return -1;
151
                return -1;
141
        }
152
        }
142
153
143
        group = EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1);
154
        group = EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1);
144
155
Line 151... Line 162...
151
                unsigned char hash[32];
162
                unsigned char hash[32];
152
163
153
                if (0 == strcmp("-c", argv[i])){
164
                if (0 == strcmp("-c", argv[i])){
154
                        i++;
165
                        i++;
155
                        if (i == argc){
166
                        if (i == argc){
156
                                fprintf(stderr, "Usage: msgcheck [-c certificate] [-p pub key] messages\n");
167
                                fprintf(stderr, "ERROR: Certificate file is not set\n");
-
 
168
                                usage();
157
                                return -1;
169
                                return -1;
158
                        }
170
                        }
159
                        len = load_certificate(argv[i], &data);
171
                        len = load_certificate(argv[i], &data);
160
                        if (len == -1){
172
                        if (len == -1){
161
                                fprintf(stderr, "%s: can not load certificate\n", argv[i]);
173
                                fprintf(stderr, "ERROR: %s: Can not load certificate from file\n", argv[i]);
162
                                return -1;
174
                                return -1;
163
                        }
175
                        }
164
                       
176
                       
165
                        calculate_certificate_digest(data, len, cert_digest);
177
                        calculate_certificate_digest(data, len, cert_digest);
166
178
167
                        if (defkey) EC_KEY_free(defkey);
179
                        if (defkey) EC_KEY_free(defkey);
168
                        defkey = get_verification_key(data, len, group);
180
                        defkey = get_verification_key(data, len, group);
169
                        free(data); data = NULL;
181
                        free(data); data = NULL;
170
                        continue;
182
                        continue;
171
                }
183
                }
172
                if (0 == strcmp("-p", argv[i])){
184
                if (0 == strcmp("-k", argv[i])){
173
                        i++;
185
                        i++;
174
                        if (i == argc){
186
                        if (i == argc){
175
                                fprintf(stderr, "Usage: msgcheck [-c certificate] [-p pub key] [-x|-b] messages\n");
187
                                fprintf(stderr, "ERROR: Public key file is not set\n");
176
                                return -1;
188
                                usage();
177
                        }
189
                        }
178
                        if (defkey) EC_KEY_free(defkey);
190
                        if (defkey) EC_KEY_free(defkey);
179
                        defkey = load_public_key(argv[i], group);
191
                        defkey = load_public_key(argv[i], group);
180
                        if (defkey == NULL){
192
                        if (defkey == NULL){
181
                                fprintf(stderr, "%s: can not load public key\n", argv[i]);
193
                                fprintf(stderr, "ERROR: %s: can not load public key\n", argv[i]);
182
                                return -1;
194
                                return -1;
183
                        }
195
                        }
184
                        continue;
196
                        continue;
185
                }
197
                }
186
                if (0 == strcmp("-r", argv[i])){
198
                if (0 == strcmp("-r", argv[i])){
187
                        if (defkey){
199
                        if (defkey){
188
                                EC_KEY_free(defkey);
200
                                EC_KEY_free(defkey);
189
                                defkey = NULL;
201
                                defkey = NULL;
190
                        }
202
                        }
-
 
203
                        continue;
-
 
204
                }
-
 
205
                if (0 == strcmp("-E", argv[i])){
-
 
206
                        _canonicalEncoding = 1;
191
                        continue;
207
                        continue;
192
                }
208
                }
193
                e = cstraload(&data, argv[i]);
209
                e = cstraload(&data, argv[i]);
194
                if (data == NULL){
210
                if (data == NULL){
195
                        fprintf(stderr, "%s: can not load message\n", argv[i]);
211
                        fprintf(stderr, "%s: can not load message\n", argv[i]);
Line 414... Line 430...
414
430
415
static void     calculate_certificate_digest(const char* data, int length, char * digest)
431
static void     calculate_certificate_digest(const char* data, int length, char * digest)
416
{
432
{
417
        // set signature point type to X
433
        // set signature point type to X
418
        unsigned char hash[32];
434
        unsigned char hash[32];
419
        unsigned char tmp = 0;
-
 
420
        SHA256_CTX ctx;
435
        SHA256_CTX ctx;
421
436
422
        SHA256_Init(&ctx);
437
        SHA256_Init(&ctx);
-
 
438
        if (_canonicalEncoding) {
-
 
439
                unsigned char tmp = 0;
423
        SHA256_Update(&ctx, data, length - 65);
440
                SHA256_Update(&ctx, data, length - 65);
424
        SHA256_Update(&ctx, &tmp, 1);
441
                SHA256_Update(&ctx, &tmp, 1);
425
        SHA256_Update(&ctx, data + length - 64, 64);
442
                SHA256_Update(&ctx, data + length - 64, 64);
-
 
443
        }else{
-
 
444
                SHA256_Update(&ctx, data, length);
-
 
445
        }
426
        SHA256_Final(hash, &ctx);
446
        SHA256_Final(hash, &ctx);
427
        memcpy(digest, hash + 24, 8);
447
        memcpy(digest, hash + 24, 8);
428
}
448
}
-
 
449
429
/*
450
/*
430
static void print_x(FILE * f, const char * ptr, int len)
451
static void print_x(FILE * f, const char * ptr, int len)
431
{
452
{
432
        const unsigned char * b = (const unsigned char *)ptr;
453
        const unsigned char * b = (const unsigned char *)ptr;
433
        const unsigned char * e = b + len;
454
        const unsigned char * e = b + len;