Symaptic: os/security/crypto/weakcrypto/test/tasymmetric/script_gen/dsa

     1 /*

     2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 * Generates DSA test vectors.

    16 *

    17 */

    22 /**

    23  @file

    24 */

    26 #include <stdio.h>

    27 #include <openssl/crypto.h>

    28 #include <openssl/rand.h>

    29 #include <openssl/dsa.h>

    30 #include "utils.h"

    32 /*

    33  * The DSA keys have been choosen from randomly generated ones so that either

    34  * the 2nd or 3rd most significant bit of q is set - this is so that a

    35  * particular path is followed when the signing procedure generates k, for which

    36  * our function that generates a random number in a certain range is equivalent

    37  * to the openssl one.

    38  *

    39  * This is nasty, but it means we don't have to change the openssl code.

    40  */

    42 static DSA* createDSAKey1()

    43 	{

    44 	unsigned char p_data[] =

    45 		"\x8d\xf2\xa4\x94\x49\x22\x76\xaa\x3d\x25\x75\x9b\xb0\x68\x69\xcb"

    46 		"\xea\xc0\xd8\x3a\xfb\x8d\x0c\xf7\xcb\xb8\x32\x4f\x0d\x78\x82\xe5"

    47 		"\xd0\x76\x2f\xc5\xb7\x21\x0e\xaf\xc2\xe9\xad\xac\x32\xab\x7a\xac"

    48 		"\x49\x69\x3d\xfb\xf8\x37\x24\xc2\xec\x07\x36\xee\x31\xc8\x02\x91";

    50 	int p_data_len = 64;

    52 	unsigned char q_data[] =

    53 		"\xc7\x73\x21\x8c\x73\x7e\xc8\xee\x99\x3b\x4f\x2d\xed\x30\xf4\x8e"

    54 		"\xda\xce\x91\x5f";

    56 	int q_data_len = 20;

    58 	unsigned char g_data[] =

    59 		"\x62\x6d\x02\x78\x39\xea\x0a\x13\x41\x31\x63\xa5\x5b\x4c\xb5\x00"

    60 		"\x29\x9d\x55\x22\x95\x6c\xef\xcb\x3b\xff\x10\xf3\x99\xce\x2c\x2e"

    61 		"\x71\xcb\x9d\xe5\xfa\x24\xba\xbf\x58\xe5\xb7\x95\x21\x92\x5c\x9c"

    62 		"\xc4\x2e\x9f\x6f\x46\x4b\x08\x8c\xc5\x72\xaf\x53\xe6\xd7\x88\x02";

    64 	int g_data_len = 64;

    66 	unsigned char priv_key_data[] =

    67 		"\xc2\x5f\xb4\x81\xd7\x9c\x07\x30\x97\xc2\x1d\x0c\xb1\xd7\x07\x2f"

    68 		"\x04\x1d\xbb\x89";

    70 	int priv_key_data_len = 20;

    72 	unsigned char pub_key_data[] =

    73 		"\x2d\x52\x1e\x27\x37\xe7\xdb\xdb\xd1\xe4\x7a\xb6\x79\xc5\xae\x69"

    74 		"\xe1\x25\x37\xe9\x96\xb1\x81\xba\xf0\xb8\x85\x0f\x84\xc8\x2b\x9e"

    75 		"\xf5\xb8\xb6\xc2\xb2\x22\x1b\xb5\xa9\xd0\x58\x66\x32\x5a\xb1\x62"

    76 		"\xae\xb7\x13\x68\xbd\xe4\xca\xa0\xf6\x68\x96\x3c\x7d\x1a\x43\x52";

    78 	int pub_key_data_len = 64;

    80 	DSA* key = DSA_new();

    81 	key->p = BN_new();

    82 	key->q = BN_new();

    83 	key->g = BN_new();

    84 	key->priv_key = BN_new();

    85 	key->pub_key = BN_new();

    87 	BN_bin2bn(p_data, p_data_len, key->p);

    88 	BN_bin2bn(q_data, q_data_len, key->q);

    89 	BN_bin2bn(g_data, g_data_len, key->g);

    90 	BN_bin2bn(pub_key_data, pub_key_data_len, key->pub_key);

    91 	BN_bin2bn(priv_key_data, priv_key_data_len, key->priv_key);

    93 	return key;

    94 	}

    96 static DSA* createDSAKey2()

    97 	{

    98 	unsigned char p_data[] =

    99 		"\x8d\xf2\xa4\x94\x49\x22\x76\xaa\x3d\x25\x75\x9b\xb0\x68\x69\xcb"

   100 		"\xea\xc0\xd8\x3a\xfb\x8d\x0c\xf7\xcb\xb8\x32\x4f\x0d\x78\x82\xe5"

   101 		"\xd0\x76\x2f\xc5\xb7\x21\x0e\xaf\xc2\xe9\xad\xac\x32\xab\x7a\xac"

   102 		"\x49\x69\x3d\xfb\xf8\x37\x24\xc2\xec\x07\x36\xee\x31\xc8\x02\x91";

   104 	int p_data_len = 64;

   106 	unsigned char q_data[] =

   107 		"\xc7\x73\x21\x8c\x73\x7e\xc8\xee\x99\x3b\x4f\x2d\xed\x30\xf4\x8e"

   108 		"\xda\xce\x91\x5f";

   110 	int q_data_len = 20;

   112 	unsigned char g_data[] =

   113 		"\x62\x6d\x02\x78\x39\xea\x0a\x13\x41\x31\x63\xa5\x5b\x4c\xb5\x00"

   114 		"\x29\x9d\x55\x22\x95\x6c\xef\xcb\x3b\xff\x10\xf3\x99\xce\x2c\x2e"

   115 		"\x71\xcb\x9d\xe5\xfa\x24\xba\xbf\x58\xe5\xb7\x95\x21\x92\x5c\x9c"

   116 		"\xc4\x2e\x9f\x6f\x46\x4b\x08\x8c\xc5\x72\xaf\x53\xe6\xd7\x88\x02";

   118 	int g_data_len = 64;

   120 	unsigned char priv_key_data[] =

   121 		"\x0f\x36\x53\xf7\x51\xa7\x04\x6e\x0b\x52\x30\xfe\x15\x7c\xa3\x3e"

   122 		"\x03\xf0\x84\x73";

   124 	int priv_key_data_len = 20;

   126 	unsigned char pub_key_data[] =

   127 		"\x7f\x9a\xd6\x6d\x4d\xa9\xb0\x0e\x71\x76\x04\xc4\xdb\x3b\x96\x93"

   128 		"\x6b\x6c\xa6\x16\xa5\x6b\xb6\xe6\x23\x26\xc7\xf5\xd4\xd6\x5b\x06"

   129 		"\x6c\x10\x47\x0a\xc2\xf2\x1d\xc1\x7b\x39\x54\x6d\x84\x99\x40\xd1"

   130 		"\x7e\xb0\xb5\x17\xc1\x17\xcd\xa0\x78\x0c\xc1\x67\xf1\x57\x83\x2c";

   132 	int pub_key_data_len = 64;

   134 	DSA* key = DSA_new();

   135 	key->p = BN_new();

   136 	key->q = BN_new();

   137 	key->g = BN_new();

   138 	key->priv_key = BN_new();

   139 	key->pub_key = BN_new();

   141 	BN_bin2bn(p_data, p_data_len, key->p);

   142 	BN_bin2bn(q_data, q_data_len, key->q);

   143 	BN_bin2bn(g_data, g_data_len, key->g);

   144 	BN_bin2bn(pub_key_data, pub_key_data_len, key->pub_key);

   145 	BN_bin2bn(priv_key_data, priv_key_data_len, key->priv_key);

   147 	return key;

   148 	}

   150 static DSA* createDSAKey3()

   151 	{

   152 	unsigned char p_data[] =

   153 		"\xcf\x62\x62\xfb\x7e\x7d\xc9\xc3\x7b\x4b\xa3\x62\x02\x1c\xfd\xb0"

   154 		"\xcc\xd7\xbe\x39\xba\x89\xfc\x86\xf4\x9b\x29\xee\xe8\xee\x47\x23"

   155 		"\xa8\x36\xd5\xbc\x3f\x31\xfe\x75\xc9\xcc\xc2\xa4\x49\x1d\x44\xc2"

   156 		"\xb2\x7a\x71\x45\xd8\xcd\x84\x41\xe5\x8a\x94\xaa\x02\x0f\xd9\x03";

   158 	int p_data_len = 64;

   160 	unsigned char q_data[] =

   161 		"\xfe\xf0\xae\xe8\x2a\x1c\x4b\xdb\xbb\xd7\xdf\x3b\xfa\xc9\x63\xfb"

   162 		"\x6d\xfc\x1e\xe7";

   164 	int q_data_len = 20;

   166 	unsigned char g_data[] =

   167 		"\x3b\x48\xa9\x2d\x82\xde\x8c\x21\x81\x09\xf8\x78\xae\xfc\x6a\xf5"

   168 		"\x0e\x2a\x90\x3d\xfb\x64\x90\x6f\x0d\xbc\xfd\x67\x4e\x2c\x56\x00"

   169 		"\xa3\x80\x25\x8a\x00\x26\x62\x10\xdc\xb6\xaa\x11\xa6\x36\x8c\x19"

   170 		"\xb9\x2a\xcc\x00\xca\x84\xd5\xeb\x8f\x9b\x50\x08\x2d\x56\x4b\x37";

   172 	int g_data_len = 64;

   174 	unsigned char priv_key_data[] =

   175 		"\x8f\xf4\xb0\xe8\x16\x94\xcb\x45\xaf\x26\xfa\x3b\x52\x96\xb3\xe9"

   176 		"\xc9\x41\xce\x18";

   178 	int priv_key_data_len = 20;

   180 	unsigned char pub_key_data[] =

   181 		"\x4e\x31\xab\x0e\x9b\xd5\x16\xaf\xf5\xc7\xf8\xe3\x1d\x01\x20\x90"

   182 		"\x3e\x11\x11\x5f\xf2\x22\x46\x5f\x08\xbb\x9e\x36\x82\xdc\xfb\x33"

   183 		"\xf9\xaa\xa5\xe9\xa0\x12\x16\x65\xc4\xbc\x7c\x6a\xf8\xb3\xc8\x8c"

   184 		"\x2e\x45\xcc\x00\xaa\x7b\x4d\xae\xae\x9a\x1d\x37\x75\xb2\xe6\x86";

   186 	int pub_key_data_len = 64;

   188 	DSA* key = DSA_new();

   189 	key->p = BN_new();

   190 	key->q = BN_new();

   191 	key->g = BN_new();

   192 	key->priv_key = BN_new();

   193 	key->pub_key = BN_new();

   195 	BN_bin2bn(p_data, p_data_len, key->p);

   196 	BN_bin2bn(q_data, q_data_len, key->q);

   197 	BN_bin2bn(g_data, g_data_len, key->g);

   198 	BN_bin2bn(pub_key_data, pub_key_data_len, key->pub_key);

   199 	BN_bin2bn(priv_key_data, priv_key_data_len, key->priv_key);

   201 	return key;

   202 	}

   204 static int digest_len = 20;

   206 static unsigned char digest1[]="12345678901234567890";

   208 static unsigned char digest2[] =

   209         "\xb1\xcd\x52\x66\x6d\x22\x60\x16\xd3\x75\x8e\x96\xa1\xff\xfa\xbc"

   210         "\x1b\x9a\xe2\xd7";

   212 static unsigned char digest3[] =

   213         "\x39\x86\x53\xec\xae\xf6\xd7\x7a\x8a\x67\x8a\x74\x20\x30\x3b\xc9"

   214         "\xda\xc9\xf3\xa7";

   215 /**

   216  * Print DSA public key.

   217  */

   219 void printDSAPublicKey(DSA* key)

   220     {

   221     printBNElement("keyP", key->p);

   222     printBNElement("keyQ", key->q);

   223     printBNElement("keyG", key->g);

   224     printBNElement("keyY", key->pub_key);

   225     }

   227 /**

   228  * Print DSA private key.

   229  */

   231 void printDSAPrivateKey(DSA* key)

   232     {

   233     printBNElement("keyP", key->p);

   234     printBNElement("keyQ", key->q);

   235     printBNElement("keyG", key->g);

   236     printBNElement("keyX", key->priv_key);

   237     }

   239 /**

   240  * Sign a message - DSA deals with generating a digest for us.

   241  */

   243 static void generateSignatureVector(DSA* key, unsigned char* mess, int len, BOOL passes)

   244     {

   245     unsigned char buf[len];

   246 	unsigned int siglen;

   247     int err;

   248     DSA_SIG* sig;

   250 	Mem::Copy(buf, mess, len);

   252     setOurRandom();

   253     sig = DSA_do_sign(buf, len, key);

   254     if (sig == NULL)

   255         processError();

   257     if (!passes)

   258         scramble(buf, len);

   260     printActionHeader("DSA test vector", "DSASignVector");

   261     printDSAPrivateKey(key);

   262     printHexElement("digest", buf, len);

   263     printBNElement("sigR", sig->r);

   264     printBNElement("sigS", sig->s);

   265     printActionFooter(passes);

   267     printActionHeader("DSA test vector", "DSAVerifyVector");

   268     printDSAPublicKey(key);

   269     printHexElement("digest", buf, len);

   270     printBNElement("sigR", sig->r);

   271     printBNElement("sigS", sig->s);

   272     printActionFooter(passes);

   274     DSA_SIG_free(sig);

   275     }

   278 int main(int argc, char **argv)

   279 	{

   280 	DSA* key1 = createDSAKey1();

   281 	DSA* key2 = createDSAKey2();

   282 	DSA* key3 = createDSAKey3();

   284     setOurRandom();

   285     testOurRandom();

   287     generateSignatureVector(key1, digest1, digest_len, TRUE);

   288     generateSignatureVector(key2, digest1, digest_len, TRUE);

   289     generateSignatureVector(key3, digest1, digest_len, TRUE);

   291     generateSignatureVector(key1, digest2, digest_len, TRUE);

   292     generateSignatureVector(key2, digest2, digest_len, TRUE);

   293     generateSignatureVector(key3, digest2, digest_len, TRUE);

   295     generateSignatureVector(key1, digest3, digest_len, TRUE);

   296     generateSignatureVector(key2, digest3, digest_len, TRUE);

   297     generateSignatureVector(key3, digest3, digest_len, TRUE);

   299     generateSignatureVector(key1, digest1, digest_len, FALSE);

   300     generateSignatureVector(key2, digest1, digest_len, FALSE);

   301     generateSignatureVector(key3, digest1, digest_len, FALSE);

   303 	return 0;

   304 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--