libmincrypt/test/ecdsa_test.c - android-core - Git at Google

 /*
  * Copyright 2013 The Android Open Source Project
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *     * Redistributions of source code must retain the above copyright
  *       notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above copyright
  *       notice, this list of conditions and the following disclaimer in the
  *       documentation and/or other materials provided with the distribution.
  *     * Neither the name of Google Inc. nor the names of its contributors may
  *       be used to endorse or promote products derived from this software
  *       without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY Google Inc. ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  * EVENT SHALL Google Inc. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/cdefs.h>

 #include "mincrypt/dsa_sig.h"
 #include "mincrypt/p256.h"
 #include "mincrypt/p256_ecdsa.h"
 #include "mincrypt/sha256.h"

 #ifndef __unused
 #define __unused __attribute__((__unused__))
 #endif

 /**
  * Messages signed using:
  *
 -----BEGIN EC PRIVATE KEY-----
 MHcCAQEEIDw6UiziVMbjlfSpOAIpA2tcL+v1OlznZLnpadO8BGi1oAoGCCqGSM49
 AwEHoUQDQgAEZw7VAOjAXYRFuhZWYBgjahdOvkwcAnjGkxQWytZW+iS1hI3ZGE24
 6XmNka9IGxAgj2n/ip+MuZJMFoJ9DRea3g==
 -----END EC PRIVATE KEY-----
  */

 p256_int key_x = {
     .a = {0xd656fa24u, 0x931416cau, 0x1c0278c6u, 0x174ebe4cu,
           0x6018236au, 0x45ba1656u, 0xe8c05d84u, 0x670ed500u}
 };
 p256_int key_y = {
     .a = {0x0d179adeu, 0x4c16827du, 0x9f8cb992u, 0x8f69ff8au,
           0x481b1020u, 0x798d91afu, 0x184db8e9u, 0xb5848dd9u}
 };

 char* message_1 =
     "f4 5d 55 f3 55 51 e9 75 d6 a8 dc 7e a9 f4 88 59"
     "39 40 cc 75 69 4a 27 8f 27 e5 78 a1 63 d8 39 b3"
     "40 40 84 18 08 cf 9c 58 c9 b8 72 8b f5 f9 ce 8e"
     "e8 11 ea 91 71 4f 47 ba b9 2d 0f 6d 5a 26 fc fe"
     "ea 6c d9 3b 91 0c 0a 2c 96 3e 64 eb 18 23 f1 02"
     "75 3d 41 f0 33 59 10 ad 3a 97 71 04 f1 aa f6 c3"
     "74 27 16 a9 75 5d 11 b8 ee d6 90 47 7f 44 5c 5d"
     "27 20 8b 2e 28 43 30 fa 3d 30 14 23 fa 7f 2d 08"
     "6e 0a d0 b8 92 b9 db 54 4e 45 6d 3f 0d ab 85 d9"
     "53 c1 2d 34 0a a8 73 ed a7 27 c8 a6 49 db 7f a6"
     "37 40 e2 5e 9a f1 53 3b 30 7e 61 32 99 93 11 0e"
     "95 19 4e 03 93 99 c3 82 4d 24 c5 1f 22 b2 6b de"
     "10 24 cd 39 59 58 a2 df eb 48 16 a6 e8 ad ed b5"
     "0b 1f 6b 56 d0 b3 06 0f f0 f1 c4 cb 0d 0e 00 1d"
     "d5 9d 73 be 12";

 char* signature_1 =
     "30 44 02 20 43 18 fc eb 3b a8 3a a8 a3 cf 41 b7"
     "81 4a f9 01 e1 8b 6e 95 c1 3a 83 25 9e a5 2e 66"
     "7c 98 25 d9 02 20 54 f3 7f 5a e9 36 9c a2 f0 51"
     "e0 6e 78 48 60 a3 f9 8a d5 2c 37 5a 0a 29 c9 f7"
     "ea 57 7e 88 46 12";

 // Same as signature 1, but with leading zeroes.
 char* message_2 =
     "f4 5d 55 f3 55 51 e9 75 d6 a8 dc 7e a9 f4 88 59"
     "39 40 cc 75 69 4a 27 8f 27 e5 78 a1 63 d8 39 b3"
     "40 40 84 18 08 cf 9c 58 c9 b8 72 8b f5 f9 ce 8e"
     "e8 11 ea 91 71 4f 47 ba b9 2d 0f 6d 5a 26 fc fe"
     "ea 6c d9 3b 91 0c 0a 2c 96 3e 64 eb 18 23 f1 02"
     "75 3d 41 f0 33 59 10 ad 3a 97 71 04 f1 aa f6 c3"
     "74 27 16 a9 75 5d 11 b8 ee d6 90 47 7f 44 5c 5d"
     "27 20 8b 2e 28 43 30 fa 3d 30 14 23 fa 7f 2d 08"
     "6e 0a d0 b8 92 b9 db 54 4e 45 6d 3f 0d ab 85 d9"
     "53 c1 2d 34 0a a8 73 ed a7 27 c8 a6 49 db 7f a6"
     "37 40 e2 5e 9a f1 53 3b 30 7e 61 32 99 93 11 0e"
     "95 19 4e 03 93 99 c3 82 4d 24 c5 1f 22 b2 6b de"
     "10 24 cd 39 59 58 a2 df eb 48 16 a6 e8 ad ed b5"
     "0b 1f 6b 56 d0 b3 06 0f f0 f1 c4 cb 0d 0e 00 1d"
     "d5 9d 73 be 12";

 char* signature_2 =
     "30 46 02 21 00 43 18 fc eb 3b a8 3a a8 a3 cf 41 b7"
     "81 4a f9 01 e1 8b 6e 95 c1 3a 83 25 9e a5 2e 66"
     "7c 98 25 d9 02 21 00 54 f3 7f 5a e9 36 9c a2 f0 51"
     "e0 6e 78 48 60 a3 f9 8a d5 2c 37 5a 0a 29 c9 f7"
     "ea 57 7e 88 46 12";

 // Excessive zeroes on the signature
 char* message_3 =
     "f4 5d 55 f3 55 51 e9 75 d6 a8 dc 7e a9 f4 88 59"
     "39 40 cc 75 69 4a 27 8f 27 e5 78 a1 63 d8 39 b3"
     "40 40 84 18 08 cf 9c 58 c9 b8 72 8b f5 f9 ce 8e"
     "e8 11 ea 91 71 4f 47 ba b9 2d 0f 6d 5a 26 fc fe"
     "ea 6c d9 3b 91 0c 0a 2c 96 3e 64 eb 18 23 f1 02"
     "75 3d 41 f0 33 59 10 ad 3a 97 71 04 f1 aa f6 c3"
     "74 27 16 a9 75 5d 11 b8 ee d6 90 47 7f 44 5c 5d"
     "27 20 8b 2e 28 43 30 fa 3d 30 14 23 fa 7f 2d 08"
     "6e 0a d0 b8 92 b9 db 54 4e 45 6d 3f 0d ab 85 d9"
     "53 c1 2d 34 0a a8 73 ed a7 27 c8 a6 49 db 7f a6"
     "37 40 e2 5e 9a f1 53 3b 30 7e 61 32 99 93 11 0e"
     "95 19 4e 03 93 99 c3 82 4d 24 c5 1f 22 b2 6b de"
     "10 24 cd 39 59 58 a2 df eb 48 16 a6 e8 ad ed b5"
     "0b 1f 6b 56 d0 b3 06 0f f0 f1 c4 cb 0d 0e 00 1d"
     "d5 9d 73 be 12";

 char* signature_3 =
     "30 4c 02 24 00 00 00 00 43 18 fc eb 3b a8 3a a8 a3 cf 41 b7"
     "81 4a f9 01 e1 8b 6e 95 c1 3a 83 25 9e a5 2e 66"
     "7c 98 25 d9 02 24 00 00 00 00 54 f3 7f 5a e9 36 9c a2 f0 51"
     "e0 6e 78 48 60 a3 f9 8a d5 2c 37 5a 0a 29 c9 f7"
     "ea 57 7e 88 46 12";


 char* good_dsa_signature_1 =
     "30 0D 02 01 01 02 08 00 A5 55 5A 01 FF A5 01";
 p256_int good_dsa_signature_1_r = {
     .a = {0x00000001U, 0x00000000U, 0x00000000U, 0x00000000U,
           0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U}
 };
 p256_int good_dsa_signature_1_s = {
     .a = {0x01FFA501U, 0x00A5555AU, 0x00000000U, 0x00000000U,
           0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U}
 };


 char* bad_dsa_signature_1 =
      "a0 06 02 01 01 02 01 01";

 char* bad_dsa_signature_2 =
      "30 07 02 01 01 02 01 01";

 char* bad_dsa_signature_3 =
      "30 06 82 01 01 02 01 01";

 char* bad_dsa_signature_4 =
      "30 06 02 00 01 02 01 01";

 char* bad_dsa_signature_5 =
      "30 06 02 01 01 82 01 01";

 char* bad_dsa_signature_6 =
      "30 05 02 01 01 02 00";

 char* bad_dsa_signature_7 =
      "30 06 02 01 01 02 00 01";

 unsigned char* parsehex(char* str, int* len) {
     // result can't be longer than input
     unsigned char* result = malloc(strlen(str));

     unsigned char* p = result;
     *len = 0;

     while (*str) {
         int b;

         while (isspace(*str)) str++;

         switch (*str) {
             case '0': case '1': case '2': case '3': case '4':
             case '5': case '6': case '7': case '8': case '9':
                 b = (*str - '0') << 4; break;
             case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                 b = (*str - 'a' + 10) << 4; break;
             case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
                 b = (*str - 'A' + 10) << 4; break;
             case '\0':
                 return result;
             default:
                 return NULL;
         }
         str++;

         while (isspace(*str)) str++;

         switch (*str) {
             case '0': case '1': case '2': case '3': case '4':
             case '5': case '6': case '7': case '8': case '9':
                 b |= *str - '0'; break;
             case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                 b |= *str - 'a' + 10; break;
             case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
                 b |= *str - 'A' + 10; break;
             default:
                 return NULL;
         }
         str++;

         *p++ = b;
         ++*len;
     }

     return result;
 }

 int main(int arg __unused, char** argv __unused) {

     unsigned char hash_buf[SHA256_DIGEST_SIZE];

     unsigned char* message;
     int mlen;
     unsigned char* signature;
     int slen;

     p256_int hash;
     p256_int r;
     p256_int s;

     int success = 1;

 #define CHECK_DSA_SIG(sig, good) do {\
     message = parsehex(sig, &mlen); \
     int result = dsa_sig_unpack(message, mlen, &r, &s); \
     printf(#sig ": %s\n", result ? "good" : "bad"); \
     success = success && !(good ^ result); \
     free(message); \
     } while(0)
 #define CHECK_GOOD_DSA_SIG(n) do {\
     CHECK_DSA_SIG(good_dsa_signature_##n, 1); \
     int result = !memcmp(P256_DIGITS(&good_dsa_signature_##n##_r), P256_DIGITS(&r), \
                          P256_NBYTES); \
     success = success && result; \
     printf("    R value %s\n", result ? "good" : "bad"); \
     result = !memcmp(P256_DIGITS(&good_dsa_signature_##n##_s), P256_DIGITS(&s), \
                     P256_NBYTES); \
     success = success && result; \
     printf("    S value %s\n", result ? "good" : "bad"); \
     } while (0)
 #define CHECK_BAD_DSA_SIG(n) \
     CHECK_DSA_SIG(bad_dsa_signature_##n, 0)

     CHECK_GOOD_DSA_SIG(1);

     CHECK_BAD_DSA_SIG(1);
     CHECK_BAD_DSA_SIG(2);
     CHECK_BAD_DSA_SIG(3);
     CHECK_BAD_DSA_SIG(4);
     CHECK_BAD_DSA_SIG(5);
     CHECK_BAD_DSA_SIG(6);
     CHECK_BAD_DSA_SIG(7);


 #define TEST_MESSAGE(n) do {\
     message = parsehex(message_##n, &mlen); \
     SHA256_hash(message, mlen, hash_buf); \
     p256_from_bin(hash_buf, &hash); \
     signature = parsehex(signature_##n, &slen); \
     int result = dsa_sig_unpack(signature, slen, &r, &s); \
     if (result) { result = p256_ecdsa_verify(&key_x, &key_y, &hash, &r, &s); } \
     printf("message %d: %s\n", n, result ? "verified" : "not verified"); \
     success = success && result; \
     free(signature); \
     } while(0)

     TEST_MESSAGE(1);
     TEST_MESSAGE(2);
     TEST_MESSAGE(3);

     printf("\n%s\n\n", success ? "PASS" : "FAIL");

     return !success;
 }
	/*
	* Copyright 2013 The Android Open Source Project
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	* * Neither the name of Google Inc. nor the names of its contributors may
	* be used to endorse or promote products derived from this software
	* without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY Google Inc. ``AS IS'' AND ANY EXPRESS OR
	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
	* EVENT SHALL Google Inc. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
	* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include <ctype.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/cdefs.h>

	#include "mincrypt/dsa_sig.h"
	#include "mincrypt/p256.h"
	#include "mincrypt/p256_ecdsa.h"
	#include "mincrypt/sha256.h"

	#ifndef __unused
	#define __unused __attribute__((__unused__))
	#endif

	/**
	* Messages signed using:
	*
	-----BEGIN EC PRIVATE KEY-----
	MHcCAQEEIDw6UiziVMbjlfSpOAIpA2tcL+v1OlznZLnpadO8BGi1oAoGCCqGSM49
	AwEHoUQDQgAEZw7VAOjAXYRFuhZWYBgjahdOvkwcAnjGkxQWytZW+iS1hI3ZGE24
	6XmNka9IGxAgj2n/ip+MuZJMFoJ9DRea3g==
	-----END EC PRIVATE KEY-----
	*/

	p256_int key_x = {
	.a = {0xd656fa24u, 0x931416cau, 0x1c0278c6u, 0x174ebe4cu,
	0x6018236au, 0x45ba1656u, 0xe8c05d84u, 0x670ed500u}
	};
	p256_int key_y = {
	.a = {0x0d179adeu, 0x4c16827du, 0x9f8cb992u, 0x8f69ff8au,
	0x481b1020u, 0x798d91afu, 0x184db8e9u, 0xb5848dd9u}
	};

	char* message_1 =
	"f4 5d 55 f3 55 51 e9 75 d6 a8 dc 7e a9 f4 88 59"
	"39 40 cc 75 69 4a 27 8f 27 e5 78 a1 63 d8 39 b3"
	"40 40 84 18 08 cf 9c 58 c9 b8 72 8b f5 f9 ce 8e"
	"e8 11 ea 91 71 4f 47 ba b9 2d 0f 6d 5a 26 fc fe"
	"ea 6c d9 3b 91 0c 0a 2c 96 3e 64 eb 18 23 f1 02"
	"75 3d 41 f0 33 59 10 ad 3a 97 71 04 f1 aa f6 c3"
	"74 27 16 a9 75 5d 11 b8 ee d6 90 47 7f 44 5c 5d"
	"27 20 8b 2e 28 43 30 fa 3d 30 14 23 fa 7f 2d 08"
	"6e 0a d0 b8 92 b9 db 54 4e 45 6d 3f 0d ab 85 d9"
	"53 c1 2d 34 0a a8 73 ed a7 27 c8 a6 49 db 7f a6"
	"37 40 e2 5e 9a f1 53 3b 30 7e 61 32 99 93 11 0e"
	"95 19 4e 03 93 99 c3 82 4d 24 c5 1f 22 b2 6b de"
	"10 24 cd 39 59 58 a2 df eb 48 16 a6 e8 ad ed b5"
	"0b 1f 6b 56 d0 b3 06 0f f0 f1 c4 cb 0d 0e 00 1d"
	"d5 9d 73 be 12";

	char* signature_1 =
	"30 44 02 20 43 18 fc eb 3b a8 3a a8 a3 cf 41 b7"
	"81 4a f9 01 e1 8b 6e 95 c1 3a 83 25 9e a5 2e 66"
	"7c 98 25 d9 02 20 54 f3 7f 5a e9 36 9c a2 f0 51"
	"e0 6e 78 48 60 a3 f9 8a d5 2c 37 5a 0a 29 c9 f7"
	"ea 57 7e 88 46 12";

	// Same as signature 1, but with leading zeroes.
	char* message_2 =
	"f4 5d 55 f3 55 51 e9 75 d6 a8 dc 7e a9 f4 88 59"
	"39 40 cc 75 69 4a 27 8f 27 e5 78 a1 63 d8 39 b3"
	"40 40 84 18 08 cf 9c 58 c9 b8 72 8b f5 f9 ce 8e"
	"e8 11 ea 91 71 4f 47 ba b9 2d 0f 6d 5a 26 fc fe"
	"ea 6c d9 3b 91 0c 0a 2c 96 3e 64 eb 18 23 f1 02"
	"75 3d 41 f0 33 59 10 ad 3a 97 71 04 f1 aa f6 c3"
	"74 27 16 a9 75 5d 11 b8 ee d6 90 47 7f 44 5c 5d"
	"27 20 8b 2e 28 43 30 fa 3d 30 14 23 fa 7f 2d 08"
	"6e 0a d0 b8 92 b9 db 54 4e 45 6d 3f 0d ab 85 d9"
	"53 c1 2d 34 0a a8 73 ed a7 27 c8 a6 49 db 7f a6"
	"37 40 e2 5e 9a f1 53 3b 30 7e 61 32 99 93 11 0e"
	"95 19 4e 03 93 99 c3 82 4d 24 c5 1f 22 b2 6b de"
	"10 24 cd 39 59 58 a2 df eb 48 16 a6 e8 ad ed b5"
	"0b 1f 6b 56 d0 b3 06 0f f0 f1 c4 cb 0d 0e 00 1d"
	"d5 9d 73 be 12";

	char* signature_2 =
	"30 46 02 21 00 43 18 fc eb 3b a8 3a a8 a3 cf 41 b7"
	"81 4a f9 01 e1 8b 6e 95 c1 3a 83 25 9e a5 2e 66"
	"7c 98 25 d9 02 21 00 54 f3 7f 5a e9 36 9c a2 f0 51"
	"e0 6e 78 48 60 a3 f9 8a d5 2c 37 5a 0a 29 c9 f7"
	"ea 57 7e 88 46 12";

	// Excessive zeroes on the signature
	char* message_3 =
	"f4 5d 55 f3 55 51 e9 75 d6 a8 dc 7e a9 f4 88 59"
	"39 40 cc 75 69 4a 27 8f 27 e5 78 a1 63 d8 39 b3"
	"40 40 84 18 08 cf 9c 58 c9 b8 72 8b f5 f9 ce 8e"
	"e8 11 ea 91 71 4f 47 ba b9 2d 0f 6d 5a 26 fc fe"
	"ea 6c d9 3b 91 0c 0a 2c 96 3e 64 eb 18 23 f1 02"
	"75 3d 41 f0 33 59 10 ad 3a 97 71 04 f1 aa f6 c3"
	"74 27 16 a9 75 5d 11 b8 ee d6 90 47 7f 44 5c 5d"
	"27 20 8b 2e 28 43 30 fa 3d 30 14 23 fa 7f 2d 08"
	"6e 0a d0 b8 92 b9 db 54 4e 45 6d 3f 0d ab 85 d9"
	"53 c1 2d 34 0a a8 73 ed a7 27 c8 a6 49 db 7f a6"
	"37 40 e2 5e 9a f1 53 3b 30 7e 61 32 99 93 11 0e"
	"95 19 4e 03 93 99 c3 82 4d 24 c5 1f 22 b2 6b de"
	"10 24 cd 39 59 58 a2 df eb 48 16 a6 e8 ad ed b5"
	"0b 1f 6b 56 d0 b3 06 0f f0 f1 c4 cb 0d 0e 00 1d"
	"d5 9d 73 be 12";

	char* signature_3 =
	"30 4c 02 24 00 00 00 00 43 18 fc eb 3b a8 3a a8 a3 cf 41 b7"
	"81 4a f9 01 e1 8b 6e 95 c1 3a 83 25 9e a5 2e 66"
	"7c 98 25 d9 02 24 00 00 00 00 54 f3 7f 5a e9 36 9c a2 f0 51"
	"e0 6e 78 48 60 a3 f9 8a d5 2c 37 5a 0a 29 c9 f7"
	"ea 57 7e 88 46 12";


	char* good_dsa_signature_1 =
	"30 0D 02 01 01 02 08 00 A5 55 5A 01 FF A5 01";
	p256_int good_dsa_signature_1_r = {
	.a = {0x00000001U, 0x00000000U, 0x00000000U, 0x00000000U,
	0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U}
	};
	p256_int good_dsa_signature_1_s = {
	.a = {0x01FFA501U, 0x00A5555AU, 0x00000000U, 0x00000000U,
	0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U}
	};


	char* bad_dsa_signature_1 =
	"a0 06 02 01 01 02 01 01";

	char* bad_dsa_signature_2 =
	"30 07 02 01 01 02 01 01";

	char* bad_dsa_signature_3 =
	"30 06 82 01 01 02 01 01";

	char* bad_dsa_signature_4 =
	"30 06 02 00 01 02 01 01";

	char* bad_dsa_signature_5 =
	"30 06 02 01 01 82 01 01";

	char* bad_dsa_signature_6 =
	"30 05 02 01 01 02 00";

	char* bad_dsa_signature_7 =
	"30 06 02 01 01 02 00 01";

	unsigned char* parsehex(char* str, int* len) {
	// result can't be longer than input
	unsigned char* result = malloc(strlen(str));

	unsigned char* p = result;
	*len = 0;

	while (*str) {
	int b;

	while (isspace(*str)) str++;

	switch (*str) {
	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
	b = (*str - '0') << 4; break;
	case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
	b = (*str - 'a' + 10) << 4; break;
	case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
	b = (*str - 'A' + 10) << 4; break;
	case '\0':
	return result;
	default:
	return NULL;
	}
	str++;

	while (isspace(*str)) str++;

	switch (*str) {
	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
	b \|= *str - '0'; break;
	case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
	b \|= *str - 'a' + 10; break;
	case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
	b \|= *str - 'A' + 10; break;
	default:
	return NULL;
	}
	str++;

	*p++ = b;
	++*len;
	}

	return result;
	}

	int main(int arg __unused, char** argv __unused) {

	unsigned char hash_buf[SHA256_DIGEST_SIZE];

	unsigned char* message;
	int mlen;
	unsigned char* signature;
	int slen;

	p256_int hash;
	p256_int r;
	p256_int s;

	int success = 1;

	#define CHECK_DSA_SIG(sig, good) do {\
	message = parsehex(sig, &mlen); \
	int result = dsa_sig_unpack(message, mlen, &r, &s); \
	printf(#sig ": %s\n", result ? "good" : "bad"); \
	success = success && !(good ^ result); \
	free(message); \
	} while(0)
	#define CHECK_GOOD_DSA_SIG(n) do {\
	CHECK_DSA_SIG(good_dsa_signature_##n, 1); \
	int result = !memcmp(P256_DIGITS(&good_dsa_signature_##n##_r), P256_DIGITS(&r), \
	P256_NBYTES); \
	success = success && result; \
	printf(" R value %s\n", result ? "good" : "bad"); \
	result = !memcmp(P256_DIGITS(&good_dsa_signature_##n##_s), P256_DIGITS(&s), \
	P256_NBYTES); \
	success = success && result; \
	printf(" S value %s\n", result ? "good" : "bad"); \
	} while (0)
	#define CHECK_BAD_DSA_SIG(n) \
	CHECK_DSA_SIG(bad_dsa_signature_##n, 0)

	CHECK_GOOD_DSA_SIG(1);

	CHECK_BAD_DSA_SIG(1);
	CHECK_BAD_DSA_SIG(2);
	CHECK_BAD_DSA_SIG(3);
	CHECK_BAD_DSA_SIG(4);
	CHECK_BAD_DSA_SIG(5);
	CHECK_BAD_DSA_SIG(6);
	CHECK_BAD_DSA_SIG(7);


	#define TEST_MESSAGE(n) do {\
	message = parsehex(message_##n, &mlen); \
	SHA256_hash(message, mlen, hash_buf); \
	p256_from_bin(hash_buf, &hash); \
	signature = parsehex(signature_##n, &slen); \
	int result = dsa_sig_unpack(signature, slen, &r, &s); \
	if (result) { result = p256_ecdsa_verify(&key_x, &key_y, &hash, &r, &s); } \
	printf("message %d: %s\n", n, result ? "verified" : "not verified"); \
	success = success && result; \
	free(signature); \
	} while(0)

	TEST_MESSAGE(1);
	TEST_MESSAGE(2);
	TEST_MESSAGE(3);

	printf("\n%s\n\n", success ? "PASS" : "FAIL");

	return !success;
	}