diff options
Diffstat (limited to 'mozilla/security/nss/cmd/rsaperf')
-rw-r--r-- | mozilla/security/nss/cmd/rsaperf/Makefile | 78 | ||||
-rw-r--r-- | mozilla/security/nss/cmd/rsaperf/defkey.c | 325 | ||||
-rw-r--r-- | mozilla/security/nss/cmd/rsaperf/manifest.mn | 56 | ||||
-rw-r--r-- | mozilla/security/nss/cmd/rsaperf/rsaperf.c | 714 |
4 files changed, 1173 insertions, 0 deletions
diff --git a/mozilla/security/nss/cmd/rsaperf/Makefile b/mozilla/security/nss/cmd/rsaperf/Makefile new file mode 100644 index 0000000..7df6058 --- /dev/null +++ b/mozilla/security/nss/cmd/rsaperf/Makefile @@ -0,0 +1,78 @@ +#! gmake +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0/LGPL 2.1 +# +# The contents of this file are subject to the Mozilla Public License Version +# 1.1 (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# http://www.mozilla.org/MPL/ +# +# 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 under the +# License. +# +# The Original Code is the Netscape security libraries. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 1998-2000 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# +# Alternatively, the contents of this file may be used under the terms of +# either the GNU General Public License Version 2 or later (the "GPL"), or +# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +# in which case the provisions of the GPL or the LGPL are applicable instead +# of those above. If you wish to allow use of your version of this file only +# under the terms of either the GPL or the LGPL, and not to allow others to +# use your version of this file under the terms of the MPL, indicate your +# decision by deleting the provisions above and replace them with the notice +# and other provisions required by the GPL or the LGPL. If you do not delete +# the provisions above, a recipient may use your version of this file under +# the terms of any one of the MPL, the GPL or the LGPL. +# +# ***** END LICENSE BLOCK ***** + +####################################################################### +# (1) Include initial platform-independent assignments (MANDATORY). # +####################################################################### + +include manifest.mn + +####################################################################### +# (2) Include "global" configuration information. (OPTIONAL) # +####################################################################### + +include $(CORE_DEPTH)/coreconf/config.mk + +####################################################################### +# (3) Include "component" configuration information. (OPTIONAL) # +####################################################################### + +####################################################################### +# (4) Include "local" platform-dependent assignments (OPTIONAL). # +####################################################################### +include ../platlibs.mk + +####################################################################### +# (5) Execute "global" rules. (OPTIONAL) # +####################################################################### + +include $(CORE_DEPTH)/coreconf/rules.mk + +####################################################################### +# (6) Execute "component" rules. (OPTIONAL) # +####################################################################### + + + +####################################################################### +# (7) Execute "local" rules. (OPTIONAL). # +####################################################################### + + +include ../platrules.mk + diff --git a/mozilla/security/nss/cmd/rsaperf/defkey.c b/mozilla/security/nss/cmd/rsaperf/defkey.c new file mode 100644 index 0000000..1cc04c7 --- /dev/null +++ b/mozilla/security/nss/cmd/rsaperf/defkey.c @@ -0,0 +1,325 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * 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 under the + * License. + * + * The Original Code is the Netscape security libraries. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +/* This key is the 1024-bit test key used for speed testing of RSA private +** key ops. +*/ +#include "seccomon.h" +#include "secoidt.h" +#include "lowkeyti.h" + +#undef CONST +#define CONST + +static CONST unsigned char default_n1024[128] = { +0xc2,0xae,0x96,0x89,0xaf,0xce,0xd0,0x7b,0x3b,0x35,0xfd,0x0f,0xb1,0xf4,0x7a,0xd1, +0x3c,0x7d,0xb5,0x86,0xf2,0x68,0x36,0xc9,0x97,0xe6,0x82,0x94,0x86,0xaa,0x05,0x39, +0xec,0x11,0x51,0xcc,0x5c,0xa1,0x59,0xba,0x29,0x18,0xf3,0x28,0xf1,0x9d,0xe3,0xae, +0x96,0x5d,0x6d,0x87,0x73,0xf6,0xf6,0x1f,0xd0,0x2d,0xfb,0x2f,0x7a,0x13,0x7f,0xc8, +0x0c,0x7a,0xe9,0x85,0xfb,0xce,0x74,0x86,0xf8,0xef,0x2f,0x85,0x37,0x73,0x0f,0x62, +0x4e,0x93,0x17,0xb7,0x7e,0x84,0x9a,0x94,0x11,0x05,0xca,0x0d,0x31,0x4b,0x2a,0xc8, +0xdf,0xfe,0xe9,0x0c,0x13,0xc7,0xf2,0xad,0x19,0x64,0x28,0x3c,0xb5,0x6a,0xc8,0x4b, +0x79,0xea,0x7c,0xce,0x75,0x92,0x45,0x3e,0xa3,0x9d,0x64,0x6f,0x04,0x69,0x19,0x17 +}; + +static CONST unsigned char default_e1024[3] = { 0x01,0x00,0x01 }; + +static CONST unsigned char default_d1024[128] = { +0x13,0xcb,0xbc,0xf2,0xf3,0x35,0x8c,0x6d,0x7b,0x6f,0xd9,0xf3,0xa6,0x9c,0xbd,0x80, +0x59,0x2e,0x4f,0x2f,0x11,0xa7,0x17,0x2b,0x18,0x8f,0x0f,0xe8,0x1a,0x69,0x5f,0x6e, +0xac,0x5a,0x76,0x7e,0xd9,0x4c,0x6e,0xdb,0x47,0x22,0x8a,0x57,0x37,0x7a,0x5e,0x94, +0x7a,0x25,0xb5,0xe5,0x78,0x1d,0x3c,0x99,0xaf,0x89,0x7d,0x69,0x2e,0x78,0x9d,0x1d, +0x84,0xc8,0xc1,0xd7,0x1a,0xb2,0x6d,0x2d,0x8a,0xd9,0xab,0x6b,0xce,0xae,0xb0,0xa0, +0x58,0x55,0xad,0x5c,0x40,0x8a,0xd6,0x96,0x08,0x8a,0xe8,0x63,0xe6,0x3d,0x6c,0x20, +0x49,0xc7,0xaf,0x0f,0x25,0x73,0xd3,0x69,0x43,0x3b,0xf2,0x32,0xf8,0x3d,0x5e,0xee, +0x7a,0xca,0xd6,0x94,0x55,0xe5,0xbd,0x25,0x34,0x8d,0x63,0x40,0xb5,0x8a,0xc3,0x01 +}; + +static CONST unsigned char default_p1024[64] = { +0xf6,0x3c,0x3f,0x56,0x58,0x4f,0xb3,0x82,0x0c,0xf0,0x5b,0x42,0x36,0x1c,0x93,0xde, +0x9b,0x32,0x01,0xb1,0x48,0xf8,0x00,0x57,0x9b,0xc1,0xbe,0x66,0xc2,0xbb,0xea,0x7c, +0x75,0x29,0x2c,0x22,0xaa,0x7c,0xaf,0xbd,0x0d,0x3f,0xb0,0x64,0x97,0xf0,0x88,0x25, +0xcb,0x8d,0xc7,0x19,0x0a,0x75,0x44,0xa4,0x5a,0xc3,0xb5,0xb9,0x85,0xea,0x27,0xa7 +}; + +static CONST unsigned char default_q1024[64] = { +0xca,0x66,0xfa,0x18,0x6a,0x46,0x36,0x1c,0x46,0xfe,0x47,0xe9,0x7e,0x52,0x83,0x8a, +0xbb,0x72,0x13,0xcc,0x83,0x56,0x3d,0x64,0x22,0xdd,0xfa,0x7c,0x61,0x99,0xea,0xa4, +0xb3,0x0e,0x8f,0x79,0x10,0xab,0xba,0x4a,0x73,0xd1,0x48,0x40,0x34,0x34,0xd3,0xd2, +0x54,0x92,0xbe,0xf5,0xc8,0xc4,0x60,0x5f,0xd3,0xf7,0xce,0xbe,0x60,0x3e,0xb1,0x11 +}; + +static CONST unsigned char default_dModP1024[64] = { +0x8e,0x80,0xbf,0x87,0x11,0x04,0xcf,0x36,0x6c,0x96,0x8d,0xb9,0xfb,0xe6,0xfe,0x0c, +0xce,0x74,0x5a,0x56,0x67,0x8c,0x5f,0x66,0x54,0x56,0x04,0x03,0x24,0x9f,0xec,0x4c, +0xaa,0xe1,0x71,0x11,0x7e,0xe9,0x3a,0x2b,0x87,0x07,0x5c,0xe6,0x5a,0xa8,0x71,0xa2, +0xad,0xf3,0x17,0x4e,0x7e,0xa6,0xef,0x5a,0xce,0xcc,0x84,0xd7,0x21,0x91,0x29,0xf1 +}; + +static CONST unsigned char default_dModQ1024[64] = { +0x87,0x60,0x1d,0x02,0xdb,0x82,0x1e,0x8b,0x07,0x48,0xe8,0x5c,0x59,0xeb,0x62,0xa4, +0x15,0xff,0x95,0x12,0x82,0xfd,0xd9,0x8d,0xf2,0x6c,0x3a,0x2f,0x9b,0x30,0x51,0x6a, +0xdb,0x80,0x6f,0xa1,0xef,0xee,0x8c,0x69,0x63,0xd1,0xa4,0xdb,0x9c,0x8f,0x80,0xe5, +0xfb,0x3f,0x33,0x8e,0x3d,0x3c,0x6b,0xa1,0x6c,0xab,0x20,0x92,0xe0,0xd8,0xcd,0xa1 +}; + +static CONST unsigned char default_qInvModP1024[64] = { +0xce,0xcf,0x5a,0xad,0xc4,0x8c,0x44,0x91,0x3a,0xbc,0x7b,0xf8,0x80,0xf8,0x53,0xf5, +0x12,0x84,0x8c,0x9c,0x6b,0x33,0x93,0x0d,0xa1,0x11,0xea,0xfa,0x4a,0xc1,0xeb,0x48, +0xdc,0x44,0x86,0x93,0x1b,0x98,0xc7,0x82,0x22,0x68,0x30,0x44,0xd7,0x62,0x1b,0x90, +0x54,0x07,0x4b,0x66,0xa7,0xc5,0x75,0x5a,0x72,0x77,0x92,0xdd,0x6c,0xf3,0x37,0xab +}; + +static CONST unsigned char default_n2048[256] = { +0xb3,0x9b,0x57,0x2c,0x15,0xdf,0x6c,0x6b,0xfc,0x04,0x83,0x02,0xf5,0xb3,0x2c,0x87, +0x1b,0x9c,0xbf,0x6c,0x46,0x1d,0xdd,0xe2,0xc0,0x6d,0xfe,0xf9,0x00,0xd1,0x85,0x91, +0x17,0x0d,0x43,0x67,0xa1,0x1f,0x8b,0xcd,0x22,0x8a,0x93,0xdc,0x9f,0xf0,0x45,0x9e, +0x58,0x0f,0x99,0x87,0xe6,0x60,0xdf,0x8c,0x1a,0xa3,0x8f,0xc3,0x6c,0xa0,0x49,0x3a, +0xdb,0x7f,0xd0,0xda,0x48,0x47,0xe3,0xd6,0x1f,0x29,0xcb,0xf2,0x1d,0xf3,0x81,0xd0, +0x4d,0xf1,0x64,0xcf,0x42,0x8e,0x0f,0xe0,0x10,0x18,0x4c,0x75,0xce,0x96,0x09,0x2e, +0x52,0xa6,0x96,0xa9,0xe1,0xab,0x3e,0x6f,0xa5,0xd3,0xee,0xd8,0xb2,0x4f,0x17,0x08, +0x6d,0x43,0xd4,0xb3,0x1c,0x8a,0x4a,0x43,0x06,0xb5,0xab,0xfb,0xf4,0x34,0x2f,0x2f, +0xe1,0x43,0x7b,0xe0,0x93,0xd0,0xaa,0x42,0xa3,0xb7,0xb7,0x43,0x52,0xeb,0xf3,0x64, +0x9a,0xbc,0xa7,0xf2,0x39,0xad,0xe4,0x62,0x7d,0xbc,0x31,0x8f,0xbf,0x59,0x93,0x62, +0x88,0xc5,0xd1,0x62,0x2d,0xe3,0xc7,0x75,0xf9,0xb8,0x00,0x96,0xe0,0x05,0x87,0x35, +0x86,0x5d,0xeb,0x7c,0x20,0xf6,0xb2,0xb1,0x65,0x1f,0xdc,0x74,0xec,0xf4,0x0e,0xd1, +0xf2,0x2d,0x06,0x47,0x02,0xc5,0x18,0xdb,0x19,0xb9,0x1b,0x40,0x90,0xc8,0x74,0x5c, +0xf6,0xe8,0x17,0x64,0xf4,0xcf,0xd3,0x17,0xeb,0xd6,0x0d,0x2b,0xec,0x2a,0x9b,0xcf, +0xc4,0xf5,0xcc,0x9a,0xc3,0x5c,0x2e,0xf1,0x98,0x25,0x2b,0xe4,0x01,0x02,0x15,0x36, +0xe1,0xe0,0x2b,0xbe,0xdf,0x23,0xf1,0xde,0x2f,0x1b,0xbb,0x44,0xa7,0x12,0x2c,0x9d +}; + +static CONST unsigned char default_e2048[3] = { 0x01,0x00,0x01 }; + +static CONST unsigned char default_d2048[256] = { +0x0f,0x03,0x3f,0x08,0x1a,0x53,0xf0,0x96,0x1e,0x1c,0xaa,0x6e,0xc6,0xe6,0xd1,0x24, +0x01,0xf4,0xda,0x33,0x4c,0xb1,0x16,0x68,0xeb,0xb8,0xc6,0x05,0x3e,0x42,0x45,0x2d, +0xd9,0x85,0x6c,0x4a,0xef,0x36,0xd9,0xd2,0xad,0xbe,0x73,0x99,0x8f,0x6c,0xe0,0x04, +0xda,0x4b,0x83,0x83,0xce,0x87,0xee,0x67,0xa1,0x9a,0x66,0x5b,0xe9,0x6a,0x84,0x74, +0x7d,0x00,0x74,0x0e,0xaa,0xd8,0x07,0x7d,0x50,0x61,0x88,0x00,0x96,0xec,0x51,0xbf, +0x7d,0xa4,0x5d,0xce,0xcd,0x3b,0x5e,0xac,0x55,0xec,0x12,0x08,0x0e,0xda,0x8f,0xad, +0xe5,0x8e,0xb3,0x2d,0x44,0x05,0xb2,0x54,0x56,0xc2,0x1e,0x46,0xd2,0xb0,0xb5,0xb6, +0x28,0x9b,0xf0,0xdd,0x7f,0xd7,0x37,0x59,0xde,0xe7,0xb4,0x96,0x7c,0xd5,0x17,0xd4, +0x7e,0xe0,0xcb,0xb3,0x3c,0x5f,0x72,0x30,0xbe,0x3c,0x81,0x82,0x8e,0xb9,0xc6,0xa7, +0x23,0x71,0xf5,0x6f,0xd7,0x56,0xe4,0xee,0x3b,0x2d,0x8f,0x3e,0x43,0x98,0xc8,0xe8, +0x95,0xfd,0xc3,0x73,0xd3,0x8e,0x38,0x01,0xa5,0xc6,0xbe,0x0c,0x6b,0x6b,0x4f,0x13, +0x2f,0x66,0x8b,0x85,0xe3,0x9e,0x12,0xc0,0x52,0x60,0xec,0x4a,0xcb,0xfa,0x7e,0x7c, +0x20,0x9a,0x11,0x16,0x1a,0xb7,0x96,0xd6,0x00,0x7a,0x04,0x7b,0x17,0xcc,0x4c,0x43, +0xdc,0xd0,0x64,0x45,0x45,0xd3,0x21,0x06,0x8b,0xd6,0xb0,0xf0,0xbf,0x20,0x56,0xfd, +0x11,0x9c,0x1d,0x82,0xcd,0x34,0x16,0x75,0x63,0xac,0x51,0xd5,0x55,0xb4,0x35,0x0a, +0xc3,0x8c,0x47,0x01,0x8e,0x99,0x95,0xc5,0x99,0x21,0x79,0x66,0x1a,0xa6,0xb0,0xe9 +}; + +static CONST unsigned char default_p2048[128] = { +0xd7,0xaa,0xb4,0x8d,0xb1,0x23,0x67,0x80,0x7b,0x98,0xf7,0xe6,0xfd,0x6d,0x5c,0x98, +0x34,0x89,0x97,0xbd,0xa8,0x88,0xdd,0xb3,0xe6,0xbc,0x5f,0xb8,0xd6,0xa5,0x14,0x00, +0x4a,0x54,0x1a,0xbf,0x65,0x64,0x7d,0x39,0x55,0xff,0x27,0x0f,0x2f,0x99,0x57,0xe6, +0x69,0x89,0x1c,0xc4,0x89,0xff,0xe4,0x1f,0xa5,0x47,0xea,0x1e,0x47,0x07,0xf7,0x46, +0xa5,0x3a,0x25,0x70,0x9e,0x6d,0xe3,0x83,0xc1,0x9d,0x75,0xf5,0x67,0xb5,0x7f,0x5c, +0xf8,0x24,0xff,0x85,0x11,0x53,0xff,0x0e,0xbc,0x57,0x6f,0xc7,0x2a,0x36,0xbd,0xdd, +0x0b,0xe5,0x25,0x04,0x1f,0x48,0xbc,0xdd,0xd6,0x13,0xb8,0xe9,0xfd,0x00,0xba,0x37, +0x13,0x63,0xc2,0xd4,0x70,0xf8,0x4b,0x09,0x71,0xa8,0xbe,0xca,0x0d,0x68,0x16,0x5f +}; + +static CONST unsigned char default_q2048[128] = { +0xd5,0x32,0x38,0x82,0x14,0xed,0xd1,0x90,0x51,0xef,0x17,0xa2,0x9b,0xc3,0xb0,0x45, +0x86,0x64,0xbe,0xce,0x8f,0x85,0x78,0x18,0x7a,0xf8,0x3a,0xb7,0x17,0x7b,0x5d,0xf3, +0xe9,0xd7,0x9d,0xb3,0x2f,0x96,0x35,0x96,0x60,0x38,0xe7,0x96,0xc3,0x08,0xe6,0xf1, +0xb8,0x16,0xc0,0x1d,0xc9,0x6f,0xd3,0x99,0x14,0x8e,0xd3,0x6a,0x2b,0x6c,0x4d,0xd1, +0x71,0x1c,0x4c,0x38,0x72,0x18,0x23,0xf9,0xd1,0x6c,0xa2,0x87,0xfe,0x33,0xc2,0x9d, +0x6e,0xd0,0x80,0x62,0x44,0x7b,0x3a,0x4d,0x2f,0xff,0x5f,0x73,0xe5,0x53,0x32,0x18, +0x14,0xb2,0xdb,0x6b,0x25,0x7b,0xac,0xb4,0x3b,0x1e,0x5e,0xcd,0xec,0x01,0x99,0xdb, +0x0c,0x1f,0xc2,0xa6,0x50,0x1d,0x6d,0x7b,0x58,0x75,0x04,0x89,0x5d,0x87,0x86,0x83 +}; + +static CONST unsigned char default_dModP2048[128] = { +0xc0,0xba,0x16,0x1b,0xc1,0x3e,0xc8,0x51,0xb3,0x22,0x21,0xf7,0x54,0x66,0x14,0xa7, +0x17,0xdc,0x15,0xb4,0x31,0x16,0x0e,0x39,0xa4,0x6a,0x96,0x88,0x11,0x98,0xf7,0xe4, +0xc2,0x87,0xa2,0x57,0x83,0xfe,0x67,0x41,0x83,0xae,0x3e,0x73,0x7d,0xaf,0xe5,0x33, +0x4d,0x00,0x70,0xaa,0xda,0x3f,0xc8,0xd6,0xd6,0xd7,0x0b,0x4a,0xff,0x63,0x09,0x01, +0x22,0xca,0x71,0x86,0xd0,0xad,0x96,0xf1,0xb9,0x66,0x43,0x71,0x88,0xba,0x53,0x14, +0xfb,0xd3,0xe4,0x5c,0x3f,0xfd,0xf6,0x22,0x6f,0x01,0x1c,0x2c,0xb9,0x76,0xad,0xf9, +0x09,0x96,0x3e,0x9c,0x0e,0x70,0xec,0x06,0xba,0x36,0x69,0xbb,0x00,0x93,0x53,0xd5, +0xc0,0x08,0x18,0xa5,0xcc,0x46,0xb6,0x97,0xbb,0xf0,0x76,0x7f,0x0d,0xb8,0x04,0xb5 +}; + +static CONST unsigned char default_dModQ2048[128] = { +0xa9,0x18,0xfd,0x43,0x07,0xf0,0x9d,0x50,0x77,0xfc,0x48,0xe5,0xdb,0xe0,0x39,0xd6, +0xdb,0x42,0xdb,0x28,0xa1,0x23,0x7e,0xdf,0x03,0xe2,0x11,0x48,0x19,0xa2,0xeb,0x21, +0x44,0xaf,0x95,0x50,0x83,0x85,0x03,0x99,0xf3,0x56,0x0f,0x32,0x40,0x1d,0xb6,0x77, +0xb0,0xc8,0xb2,0xb6,0xad,0x88,0x39,0xef,0xe8,0x23,0x64,0xc2,0x88,0x10,0x8e,0x24, +0x7a,0x2f,0xb4,0xb0,0xec,0xa6,0x03,0x1a,0xe9,0xa5,0xdd,0xc0,0x39,0xba,0xba,0x38, +0xfe,0xa4,0xf7,0xbf,0x79,0x8b,0xb7,0xf1,0x73,0x09,0x7d,0x9f,0x42,0x1c,0x5b,0xd6, +0x47,0xcc,0x99,0x46,0x81,0xe3,0x77,0x57,0x38,0xb0,0xdd,0x07,0x3d,0x93,0x03,0x82, +0x7f,0x3a,0x4d,0xbc,0x76,0x3c,0xf1,0x12,0x6d,0x55,0xdb,0x34,0x4c,0xef,0xea,0x9b +}; + +static CONST unsigned char default_qInvModP2048[128] = { +0x77,0xd9,0x45,0xd4,0xd2,0xd1,0x46,0xa8,0xaf,0x57,0x8f,0x5e,0x4f,0x6b,0x24,0x0f, +0xb4,0xaa,0xff,0x92,0x86,0x78,0xa8,0xc1,0x69,0x9c,0x54,0xe9,0x81,0xa1,0x9c,0x26, +0x11,0x5d,0xfa,0xff,0x70,0x9e,0xa3,0xf3,0xe3,0x78,0x41,0x2b,0x31,0x35,0x09,0xa2, +0x5c,0x5f,0x6e,0x4d,0xad,0xeb,0x4a,0xe0,0xb1,0xce,0x2c,0x22,0x59,0x72,0x4c,0x17, +0xad,0x71,0x5c,0x25,0xca,0x4f,0x00,0xc6,0xee,0x63,0x10,0x8e,0xf7,0xbe,0xa4,0x55, +0x22,0x0d,0x2c,0xb9,0xe5,0xa9,0x72,0x07,0xa2,0xb1,0x29,0xf2,0x4a,0x9f,0xde,0x70, +0x0c,0x28,0xb7,0x60,0x12,0x9d,0x4b,0x04,0xd7,0xe3,0xd7,0xc5,0x71,0xdf,0x5c,0xc0, +0x65,0x75,0x6e,0xfb,0xc6,0x3e,0x61,0x4c,0xc2,0xdf,0xb3,0xd3,0xba,0x17,0x36,0x24 +}; + +static struct NSSLOWKEYPrivateKeyStr rsaPriv; + +NSSLOWKEYPrivateKey * +getDefaultRSAPrivateKey(int keysize) +{ + if (rsaPriv.keyType != NSSLOWKEYRSAKey) { + + /* leaving arena uninitialized. It isn't used in this test. */ + + rsaPriv.keyType = NSSLOWKEYRSAKey; + + /* leaving arena uninitialized. It isn't used. */ + /* leaving version uninitialized. It isn't used. */ + + if (keysize == 2048) { + rsaPriv.u.rsa.modulus.data = default_n2048; + rsaPriv.u.rsa.modulus.len = sizeof default_n2048; + rsaPriv.u.rsa.publicExponent.data = default_e2048; + rsaPriv.u.rsa.publicExponent.len = sizeof default_e2048; + rsaPriv.u.rsa.privateExponent.data = default_d2048; + rsaPriv.u.rsa.privateExponent.len = sizeof default_d2048; + rsaPriv.u.rsa.prime1.data = default_p2048; + rsaPriv.u.rsa.prime1.len = sizeof default_p2048; + rsaPriv.u.rsa.prime2.data = default_q2048; + rsaPriv.u.rsa.prime2.len = sizeof default_q2048; + rsaPriv.u.rsa.exponent1.data = default_dModP2048; + rsaPriv.u.rsa.exponent1.len = sizeof default_dModP2048; + rsaPriv.u.rsa.exponent2.data = default_dModQ2048; + rsaPriv.u.rsa.exponent2.len = sizeof default_dModQ2048; + rsaPriv.u.rsa.coefficient.data = default_qInvModP2048; + rsaPriv.u.rsa.coefficient.len = sizeof default_qInvModP2048; + } else { + rsaPriv.u.rsa.modulus.data = default_n1024; + rsaPriv.u.rsa.modulus.len = sizeof default_n1024; + rsaPriv.u.rsa.publicExponent.data = default_e1024; + rsaPriv.u.rsa.publicExponent.len = sizeof default_e1024; + rsaPriv.u.rsa.privateExponent.data = default_d1024; + rsaPriv.u.rsa.privateExponent.len = sizeof default_d1024; + rsaPriv.u.rsa.prime1.data = default_p1024; + rsaPriv.u.rsa.prime1.len = sizeof default_p1024; + rsaPriv.u.rsa.prime2.data = default_q1024; + rsaPriv.u.rsa.prime2.len = sizeof default_q1024; + rsaPriv.u.rsa.exponent1.data = default_dModP1024; + rsaPriv.u.rsa.exponent1.len = sizeof default_dModP1024; + rsaPriv.u.rsa.exponent2.data = default_dModQ1024; + rsaPriv.u.rsa.exponent2.len = sizeof default_dModQ1024; + rsaPriv.u.rsa.coefficient.data = default_qInvModP1024; + rsaPriv.u.rsa.coefficient.len = sizeof default_qInvModP1024; + } + } + return &rsaPriv; +} + +static struct NSSLOWKEYPublicKeyStr rsaPub; + +NSSLOWKEYPublicKey * +getDefaultRSAPublicKey(int keysize) +{ + if (rsaPub.keyType != NSSLOWKEYRSAKey) { + + rsaPub.keyType = NSSLOWKEYRSAKey; + + if (keysize == 2048) { + rsaPub.u.rsa.modulus.data = default_n2048; + rsaPub.u.rsa.modulus.len = sizeof default_n2048; + + rsaPub.u.rsa.publicExponent.data = default_e2048; + rsaPub.u.rsa.publicExponent.len = sizeof default_e2048; + } else { + rsaPub.u.rsa.modulus.data = default_n1024; + rsaPub.u.rsa.modulus.len = sizeof default_n1024; + + rsaPub.u.rsa.publicExponent.data = default_e1024; + rsaPub.u.rsa.publicExponent.len = sizeof default_e1024; + } + } + return &rsaPub; +} + +/* modPop = 536, privPop = 531, ex1Pop = 261, ex2Pop = 257 + * After 46 tries, found this key: + * Version: 0 (0x0) + * Modulus: + * c2:ae:96:89:af:ce:d0:7b:3b:35:fd:0f:b1:f4:7a:d1:3c:7d:b5: + * 86:f2:68:36:c9:97:e6:82:94:86:aa:05:39:ec:11:51:cc:5c:a1: + * 59:ba:29:18:f3:28:f1:9d:e3:ae:96:5d:6d:87:73:f6:f6:1f:d0: + * 2d:fb:2f:7a:13:7f:c8:0c:7a:e9:85:fb:ce:74:86:f8:ef:2f:85: + * 37:73:0f:62:4e:93:17:b7:7e:84:9a:94:11:05:ca:0d:31:4b:2a: + * c8:df:fe:e9:0c:13:c7:f2:ad:19:64:28:3c:b5:6a:c8:4b:79:ea: + * 7c:ce:75:92:45:3e:a3:9d:64:6f:04:69:19:17 + * Public Exponent: 65537 (0x10001) + * Private Exponent: + * 13:cb:bc:f2:f3:35:8c:6d:7b:6f:d9:f3:a6:9c:bd:80:59:2e:4f: + * 2f:11:a7:17:2b:18:8f:0f:e8:1a:69:5f:6e:ac:5a:76:7e:d9:4c: + * 6e:db:47:22:8a:57:37:7a:5e:94:7a:25:b5:e5:78:1d:3c:99:af: + * 89:7d:69:2e:78:9d:1d:84:c8:c1:d7:1a:b2:6d:2d:8a:d9:ab:6b: + * ce:ae:b0:a0:58:55:ad:5c:40:8a:d6:96:08:8a:e8:63:e6:3d:6c: + * 20:49:c7:af:0f:25:73:d3:69:43:3b:f2:32:f8:3d:5e:ee:7a:ca: + * d6:94:55:e5:bd:25:34:8d:63:40:b5:8a:c3:01 + * Prime 1: + * f6:3c:3f:56:58:4f:b3:82:0c:f0:5b:42:36:1c:93:de:9b:32:01: + * b1:48:f8:00:57:9b:c1:be:66:c2:bb:ea:7c:75:29:2c:22:aa:7c: + * af:bd:0d:3f:b0:64:97:f0:88:25:cb:8d:c7:19:0a:75:44:a4:5a: + * c3:b5:b9:85:ea:27:a7 + * Prime 2: + * ca:66:fa:18:6a:46:36:1c:46:fe:47:e9:7e:52:83:8a:bb:72:13: + * cc:83:56:3d:64:22:dd:fa:7c:61:99:ea:a4:b3:0e:8f:79:10:ab: + * ba:4a:73:d1:48:40:34:34:d3:d2:54:92:be:f5:c8:c4:60:5f:d3: + * f7:ce:be:60:3e:b1:11 + * Exponent 1: + * 8e:80:bf:87:11:04:cf:36:6c:96:8d:b9:fb:e6:fe:0c:ce:74:5a: + * 56:67:8c:5f:66:54:56:04:03:24:9f:ec:4c:aa:e1:71:11:7e:e9: + * 3a:2b:87:07:5c:e6:5a:a8:71:a2:ad:f3:17:4e:7e:a6:ef:5a:ce: + * cc:84:d7:21:91:29:f1 + * Exponent 2: + * 87:60:1d:02:db:82:1e:8b:07:48:e8:5c:59:eb:62:a4:15:ff:95: + * 12:82:fd:d9:8d:f2:6c:3a:2f:9b:30:51:6a:db:80:6f:a1:ef:ee: + * 8c:69:63:d1:a4:db:9c:8f:80:e5:fb:3f:33:8e:3d:3c:6b:a1:6c: + * ab:20:92:e0:d8:cd:a1 + * Coefficient: + * ce:cf:5a:ad:c4:8c:44:91:3a:bc:7b:f8:80:f8:53:f5:12:84:8c: + * 9c:6b:33:93:0d:a1:11:ea:fa:4a:c1:eb:48:dc:44:86:93:1b:98: + * c7:82:22:68:30:44:d7:62:1b:90:54:07:4b:66:a7:c5:75:5a:72: + * 77:92:dd:6c:f3:37:ab + */ diff --git a/mozilla/security/nss/cmd/rsaperf/manifest.mn b/mozilla/security/nss/cmd/rsaperf/manifest.mn new file mode 100644 index 0000000..2c820e3 --- /dev/null +++ b/mozilla/security/nss/cmd/rsaperf/manifest.mn @@ -0,0 +1,56 @@ +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0/LGPL 2.1 +# +# The contents of this file are subject to the Mozilla Public License Version +# 1.1 (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# http://www.mozilla.org/MPL/ +# +# 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 under the +# License. +# +# The Original Code is the Netscape security libraries. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 1998-2000 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# +# Alternatively, the contents of this file may be used under the terms of +# either the GNU General Public License Version 2 or later (the "GPL"), or +# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +# in which case the provisions of the GPL or the LGPL are applicable instead +# of those above. If you wish to allow use of your version of this file only +# under the terms of either the GPL or the LGPL, and not to allow others to +# use your version of this file under the terms of the MPL, indicate your +# decision by deleting the provisions above and replace them with the notice +# and other provisions required by the GPL or the LGPL. If you do not delete +# the provisions above, a recipient may use your version of this file under +# the terms of any one of the MPL, the GPL or the LGPL. +# +# ***** END LICENSE BLOCK ***** + +DEPTH = ../../.. +CORE_DEPTH = ../../.. + +# MODULE public and private header directories are implicitly REQUIRED. +MODULE = nss + +INCLUDES += -I$(CORE_DEPTH)/nss/lib/softoken + +# This next line is used by .mk files +# and gets translated into $LINCS in manifest.mnw +REQUIRES = dbm seccmd + +# DIRS = + +CSRCS = rsaperf.c defkey.c + +PROGRAM = rsaperf + +USE_STATIC_LIBS = 1 diff --git a/mozilla/security/nss/cmd/rsaperf/rsaperf.c b/mozilla/security/nss/cmd/rsaperf/rsaperf.c new file mode 100644 index 0000000..78b7072 --- /dev/null +++ b/mozilla/security/nss/cmd/rsaperf/rsaperf.c @@ -0,0 +1,714 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * 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 under the + * License. + * + * The Original Code is the Netscape security libraries. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#include "seccomon.h" +#include "cert.h" +#include "secutil.h" +#include "nspr.h" +#include "nss.h" +#include "blapi.h" +#include "plgetopt.h" +#include "lowkeyi.h" +#include "pk11pub.h" + + +#define DEFAULT_ITERS 10 +#define DEFAULT_DURATION 10 +#define DEFAULT_KEY_BITS 1024 +#define MIN_KEY_BITS 512 +#define MAX_KEY_BITS 65536 +#define BUFFER_BYTES MAX_KEY_BITS / 8 +#define DEFAULT_THREADS 1 +#define DEFAULT_EXPONENT 0x10001 + +extern NSSLOWKEYPrivateKey * getDefaultRSAPrivateKey(void); +extern NSSLOWKEYPublicKey * getDefaultRSAPublicKey(void); + +secuPWData pwData = { PW_NONE, NULL }; + +typedef struct TimingContextStr TimingContext; + +struct TimingContextStr { + PRTime start; + PRTime end; + PRTime interval; + + long days; + int hours; + int minutes; + int seconds; + int millisecs; +}; + +TimingContext *CreateTimingContext(void) { + return PORT_Alloc(sizeof(TimingContext)); +} + +void DestroyTimingContext(TimingContext *ctx) { + PORT_Free(ctx); +} + +void TimingBegin(TimingContext *ctx, PRTime begin) { + ctx->start = begin; +} + +static void timingUpdate(TimingContext *ctx) { + PRInt64 tmp, remaining; + PRInt64 L1000,L60,L24; + + LL_I2L(L1000,1000); + LL_I2L(L60,60); + LL_I2L(L24,24); + + LL_DIV(remaining, ctx->interval, L1000); + LL_MOD(tmp, remaining, L1000); + LL_L2I(ctx->millisecs, tmp); + LL_DIV(remaining, remaining, L1000); + LL_MOD(tmp, remaining, L60); + LL_L2I(ctx->seconds, tmp); + LL_DIV(remaining, remaining, L60); + LL_MOD(tmp, remaining, L60); + LL_L2I(ctx->minutes, tmp); + LL_DIV(remaining, remaining, L60); + LL_MOD(tmp, remaining, L24); + LL_L2I(ctx->hours, tmp); + LL_DIV(remaining, remaining, L24); + LL_L2I(ctx->days, remaining); +} + +void TimingEnd(TimingContext *ctx, PRTime end) { + ctx->end = end; + LL_SUB(ctx->interval, ctx->end, ctx->start); + PORT_Assert(LL_GE_ZERO(ctx->interval)); + timingUpdate(ctx); +} + +void TimingDivide(TimingContext *ctx, int divisor) { + PRInt64 tmp; + + LL_I2L(tmp, divisor); + LL_DIV(ctx->interval, ctx->interval, tmp); + + timingUpdate(ctx); +} + +char *TimingGenerateString(TimingContext *ctx) { + char *buf = NULL; + + if (ctx->days != 0) { + buf = PR_sprintf_append(buf, "%d days", ctx->days); + } + if (ctx->hours != 0) { + if (buf != NULL) buf = PR_sprintf_append(buf, ", "); + buf = PR_sprintf_append(buf, "%d hours", ctx->hours); + } + if (ctx->minutes != 0) { + if (buf != NULL) buf = PR_sprintf_append(buf, ", "); + buf = PR_sprintf_append(buf, "%d minutes", ctx->minutes); + } + if (buf != NULL) buf = PR_sprintf_append(buf, ", and "); + if (!buf && ctx->seconds == 0) { + int interval; + LL_L2I(interval, ctx->interval); + if (ctx->millisecs < 100) + buf = PR_sprintf_append(buf, "%d microseconds", interval); + else + buf = PR_sprintf_append(buf, "%d milliseconds", ctx->millisecs); + } else if (ctx->millisecs == 0) { + buf = PR_sprintf_append(buf, "%d seconds", ctx->seconds); + } else { + buf = PR_sprintf_append(buf, "%d.%03d seconds", + ctx->seconds, ctx->millisecs); + } + return buf; +} + +void +Usage(char *progName) +{ + fprintf(stderr, "Usage: %s [-s | -e] [-i iterations | -p period] " + "[-t threads]\n[-n none [-k keylength] [ [-g] -x exponent] |\n" + " -n token:nickname [-d certdir] [-w password] |\n" + " -h token [-d certdir] [-w password] [-g] [-k keylength] " + "[-x exponent] [-f pwfile]\n", + progName); + fprintf(stderr, "%-20s Cert database directory (default is ~/.netscape)\n", + "-d certdir"); + fprintf(stderr, "%-20s How many operations to perform\n", "-i iterations"); + fprintf(stderr, "%-20s How many seconds to run\n", "-p period"); + fprintf(stderr, "%-20s Perform signing (private key) operations\n", "-s"); + fprintf(stderr, "%-20s Perform encryption (public key) operations\n","-e"); + fprintf(stderr, "%-20s Nickname of certificate or key, prefixed " + "by optional token name\n", "-n nickname"); + fprintf(stderr, "%-20s PKCS#11 token to perform operation with.\n", + "-h token"); + fprintf(stderr, "%-20s key size in bits, from %d to %d\n", "-k keylength", + MIN_KEY_BITS, MAX_KEY_BITS); + fprintf(stderr, "%-20s token password\n", "-w password"); + fprintf(stderr, "%-20s temporary key generation. Not for token keys.\n", + "-g"); + fprintf(stderr, "%-20s set public exponent for keygen\n", "-x"); + fprintf(stderr, "%-20s Number of execution threads (default 1)\n", + "-t threads"); + exit(-1); +} + +static void +dumpBytes( unsigned char * b, int l) +{ + int i; + if (l <= 0) + return; + for (i = 0; i < l; ++i) { + if (i % 16 == 0) + printf("\t"); + printf(" %02x", b[i]); + if (i % 16 == 15) + printf("\n"); + } + if ((i % 16) != 0) + printf("\n"); +} + +static void +dumpItem( SECItem * item, const char * description) +{ + if (item->len & 1 && item->data[0] == 0) { + printf("%s: (%d bytes)\n", description, item->len - 1); + dumpBytes(item->data + 1, item->len - 1); + } else { + printf("%s: (%d bytes)\n", description, item->len); + dumpBytes(item->data, item->len); + } +} + +void +printPrivKey(NSSLOWKEYPrivateKey * privKey) +{ + RSAPrivateKey *rsa = &privKey->u.rsa; + + dumpItem( &rsa->modulus, "n"); + dumpItem( &rsa->publicExponent, "e"); + dumpItem( &rsa->privateExponent, "d"); + dumpItem( &rsa->prime1, "P"); + dumpItem( &rsa->prime2, "Q"); + dumpItem( &rsa->exponent1, "d % (P-1)"); + dumpItem( &rsa->exponent2, "d % (Q-1)"); + dumpItem( &rsa->coefficient, "(Q ** -1) % P"); + puts(""); +} + +typedef SECStatus (* RSAOp)(void * key, + unsigned char * output, + unsigned char * input); + +typedef struct { + SECKEYPublicKey* pubKey; + SECKEYPrivateKey* privKey; +} PK11Keys; + + +SECStatus PK11_PublicKeyOp (SECKEYPublicKey* key, + unsigned char * output, + unsigned char * input) +{ + return PK11_PubEncryptRaw(key, output, input, key->u.rsa.modulus.len, + NULL); +} + +SECStatus PK11_PrivateKeyOp (PK11Keys* keys, + unsigned char * output, + unsigned char * input) +{ + unsigned outLen = 0; + return PK11_PrivDecryptRaw(keys->privKey, + output, &outLen, + keys->pubKey->u.rsa.modulus.len, input, + keys->pubKey->u.rsa.modulus.len); +} +typedef struct ThreadRunDataStr ThreadRunData; + +struct ThreadRunDataStr { + const PRBool *doIters; + const void *rsaKey; + const unsigned char *buf; + RSAOp fn; + int seconds; + long iters; + long iterRes; + PRErrorCode errNum; + SECStatus status; +}; + + +void ThreadExecFunction(void *data) +{ + ThreadRunData *tdata = (ThreadRunData*)data; + unsigned char buf2[BUFFER_BYTES]; + + tdata->status = SECSuccess; + if (*tdata->doIters) { + long i = tdata->iters; + tdata->iterRes = 0; + while (i--) { + SECStatus rv = tdata->fn((void*)tdata->rsaKey, buf2, + (unsigned char*)tdata->buf); + if (rv != SECSuccess) { + tdata->errNum = PORT_GetError(); + tdata->status = rv; + break; + } + tdata->iterRes++; + } + } else { + PRIntervalTime total = PR_SecondsToInterval(tdata->seconds); + PRIntervalTime start = PR_IntervalNow(); + tdata->iterRes = 0; + while (PR_IntervalNow() - start < total) { + SECStatus rv = tdata->fn((void*)tdata->rsaKey, buf2, + (unsigned char*)tdata->buf); + if (rv != SECSuccess) { + tdata->errNum = PORT_GetError(); + tdata->status = rv; + break; + } + tdata->iterRes++; + } + } +} + +#define INT_ARG(arg,def) atol(arg)>0?atol(arg):def + +int +main(int argc, char **argv) +{ + TimingContext * timeCtx = NULL; + SECKEYPublicKey * pubHighKey = NULL; + SECKEYPrivateKey * privHighKey = NULL; + NSSLOWKEYPrivateKey * privKey = NULL; + NSSLOWKEYPublicKey * pubKey = NULL; + CERTCertificate * cert = NULL; + char * progName = NULL; + char * secDir = NULL; + char * nickname = NULL; + char * slotname = NULL; + long keybits = 0; + RSAOp fn; + void * rsaKey = NULL; + PLOptState * optstate; + PLOptStatus optstatus; + long iters = DEFAULT_ITERS; + int i; + PRBool doPriv = PR_FALSE; + PRBool doPub = PR_FALSE; + int rv; + unsigned char buf[BUFFER_BYTES]; + unsigned char buf2[BUFFER_BYTES]; + int seconds = DEFAULT_DURATION; + PRBool doIters = PR_FALSE; + PRBool doTime = PR_FALSE; + PRBool useTokenKey = PR_FALSE; /* use PKCS#11 token + object key */ + PRBool useSessionKey = PR_FALSE; /* use PKCS#11 session + object key */ + PRBool useBLKey = PR_FALSE; /* use freebl */ + PK11SlotInfo* slot = NULL; /* slot for session + object key operations */ + PRBool doKeyGen = PR_FALSE; + int publicExponent = DEFAULT_EXPONENT; + PK11Keys keys; + int peCount = 0; + CK_BYTE pubEx[4]; + SECItem pe; + RSAPublicKey pubKeyStr; + int threadNum = DEFAULT_THREADS; + ThreadRunData ** runDataArr = NULL; + PRThread ** threadsArr = NULL; + int calcThreads = 0; + + progName = strrchr(argv[0], '/'); + if (!progName) + progName = strrchr(argv[0], '\\'); + progName = progName ? progName+1 : argv[0]; + + optstate = PL_CreateOptState(argc, argv, "d:ef:gh:i:k:n:p:st:w:x:"); + while ((optstatus = PL_GetNextOpt(optstate)) == PL_OPT_OK) { + switch (optstate->option) { + case '?': + Usage(progName); + break; + case 'd': + secDir = PORT_Strdup(optstate->value); + break; + case 'i': + iters = INT_ARG(optstate->value, DEFAULT_ITERS); + doIters = PR_TRUE; + break; + case 's': + doPriv = PR_TRUE; + break; + case 'e': + doPub = PR_TRUE; + break; + case 'g': + doKeyGen = PR_TRUE; + break; + case 'n': + nickname = PORT_Strdup(optstate->value); + /* for compatibility, nickname of "none" means go to freebl */ + if (nickname && strcmp(nickname, "none")) { + useTokenKey = PR_TRUE; + } else { + useBLKey = PR_TRUE; + } + break; + case 'p': + seconds = INT_ARG(optstate->value, DEFAULT_DURATION); + doTime = PR_TRUE; + break; + case 'h': + slotname = PORT_Strdup(optstate->value); + useSessionKey = PR_TRUE; + break; + case 'k': + keybits = INT_ARG(optstate->value, DEFAULT_KEY_BITS); + break; + case 'w': + pwData.data = PORT_Strdup(optstate->value);; + pwData.source = PW_PLAINTEXT; + break; + case 'f': + pwData.data = PORT_Strdup(optstate->value); + pwData.source = PW_FROMFILE; + break; + case 'x': + /* -x public exponent (for RSA keygen) */ + publicExponent = INT_ARG(optstate->value, DEFAULT_EXPONENT); + break; + case 't': + threadNum = INT_ARG(optstate->value, DEFAULT_THREADS); + break; + } + } + if (optstatus == PL_OPT_BAD) + Usage(progName); + + if ((doPriv && doPub) || (doIters && doTime) || + ((useTokenKey + useSessionKey + useBLKey) != PR_TRUE) || + (useTokenKey && keybits) || (useTokenKey && doKeyGen) || + (keybits && (keybits<MIN_KEY_BITS || keybits>MAX_KEY_BITS))) { + Usage(progName); + } + + if (!doPriv && !doPub) doPriv = PR_TRUE; + + if (doIters && doTime) Usage(progName); + + if (!doTime) { + doIters = PR_TRUE; + } + + PR_Init( PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1); + + PK11_SetPasswordFunc(SECU_GetModulePassword); + secDir = SECU_ConfigDirectory(secDir); + + if (useTokenKey || useSessionKey) { + rv = NSS_Init(secDir); + if (rv != SECSuccess) { + fprintf(stderr, "NSS_Init failed.\n"); + exit(1); + } + } else { + rv = NSS_NoDB_Init(NULL); + if (rv != SECSuccess) { + fprintf(stderr, "NSS_NoDB_Init failed.\n"); + exit(1); + } + } + + if (useTokenKey) { + CK_OBJECT_HANDLE kh = CK_INVALID_HANDLE; + CERTCertDBHandle* certdb = NULL; + certdb = CERT_GetDefaultCertDB(); + + cert = PK11_FindCertFromNickname(nickname, &pwData); + if (cert == NULL) { + fprintf(stderr, + "Can't find certificate by name \"%s\"\n", nickname); + exit(1); + } + pubHighKey = CERT_ExtractPublicKey(cert); + if (pubHighKey == NULL) { + fprintf(stderr, "Can't extract public key from certificate"); + exit(1); + } + + if (doPub) { + /* do public key ops */ + fn = (RSAOp)PK11_PublicKeyOp; + rsaKey = (void *) pubHighKey; + + kh = PK11_ImportPublicKey(cert->slot, pubHighKey, PR_FALSE); + if (CK_INVALID_HANDLE == kh) { + fprintf(stderr, + "Unable to import public key to certificate slot."); + exit(1); + } + pubHighKey->pkcs11Slot = PK11_ReferenceSlot(cert->slot); + pubHighKey->pkcs11ID = kh; + printf("Using PKCS#11 for RSA encryption with token %s.\n", + PK11_GetTokenName(cert->slot)); + } else { + /* do private key ops */ + privHighKey = PK11_FindKeyByAnyCert(cert, &pwData); + if (privHighKey == NULL) { + fprintf(stderr, + "Can't find private key by name \"%s\"\n", nickname); + exit(1); + } + + SECKEY_CacheStaticFlags(privHighKey); + fn = (RSAOp)PK11_PrivateKeyOp; + keys.privKey = privHighKey; + keys.pubKey = pubHighKey; + rsaKey = (void *) &keys; + printf("Using PKCS#11 for RSA decryption with token %s.\n", + PK11_GetTokenName(privHighKey->pkcs11Slot)); + } + } else + + if (useSessionKey) { + /* use PKCS#11 session key objects */ + PK11RSAGenParams rsaparams; + void * params; + + slot = PK11_FindSlotByName(slotname); /* locate target slot */ + if (!slot) { + fprintf(stderr, "Can't find slot \"%s\"\n", slotname); + exit(1); + } + + doKeyGen = PR_TRUE; /* Always do a keygen for session keys. + Import of hardcoded key is not supported */ + /* do a temporary keygen in selected slot */ + if (!keybits) { + keybits = DEFAULT_KEY_BITS; + } + + printf("Using PKCS#11 with %ld bits session key in token %s.\n", + keybits, PK11_GetTokenName(slot)); + + rsaparams.keySizeInBits = keybits; + rsaparams.pe = publicExponent; + params = &rsaparams; + + fprintf(stderr,"\nGenerating RSA key. This may take a few moments.\n"); + + privHighKey = PK11_GenerateKeyPair(slot, CKM_RSA_PKCS_KEY_PAIR_GEN, + params, &pubHighKey, PR_FALSE, + PR_FALSE, (void*)&pwData); + if (!privHighKey) { + fprintf(stderr, + "Key generation failed in token \"%s\"\n", + PK11_GetTokenName(slot)); + exit(1); + } + + SECKEY_CacheStaticFlags(privHighKey); + + fprintf(stderr,"Keygen completed.\n"); + + if (doPub) { + /* do public key operations */ + fn = (RSAOp)PK11_PublicKeyOp; + rsaKey = (void *) pubHighKey; + } else { + /* do private key operations */ + fn = (RSAOp)PK11_PrivateKeyOp; + keys.privKey = privHighKey; + keys.pubKey = pubHighKey; + rsaKey = (void *) &keys; + } + } else + + { + /* use freebl directly */ + if (!keybits) { + keybits = DEFAULT_KEY_BITS; + } + if (!doKeyGen) { + if (keybits != DEFAULT_KEY_BITS) { + doKeyGen = PR_TRUE; + } + } + printf("Using freebl with %ld bits key.\n", keybits); + if (doKeyGen) { + fprintf(stderr,"\nGenerating RSA key. " + "This may take a few moments.\n"); + for (i=0; i < 4; i++) { + if (peCount || (publicExponent & ((unsigned long)0xff000000L >> + (i*8)))) { + pubEx[peCount] = (CK_BYTE)((publicExponent >> + (3-i)*8) & 0xff); + peCount++; + } + } + pe.len = peCount; + pe.data = &pubEx[0]; + pe.type = siBuffer; + + rsaKey = RSA_NewKey(keybits, &pe); + fprintf(stderr,"Keygen completed.\n"); + } else { + /* use a hardcoded key */ + printf("Using hardcoded %ld bits key.\n", keybits); + if (doPub) { + pubKey = getDefaultRSAPublicKey(); + } else { + privKey = getDefaultRSAPrivateKey(); + } + } + + if (doPub) { + /* do public key operations */ + fn = (RSAOp)RSA_PublicKeyOp; + if (rsaKey) { + /* convert the RSAPrivateKey to RSAPublicKey */ + pubKeyStr.arena = NULL; + pubKeyStr.modulus = ((RSAPrivateKey*)rsaKey)->modulus; + pubKeyStr.publicExponent = + ((RSAPrivateKey*)rsaKey)->publicExponent; + rsaKey = &pubKeyStr; + } else { + /* convert NSSLOWKeyPublicKey to RSAPublicKey */ + rsaKey = (void *)(&pubKey->u.rsa); + } + PORT_Assert(rsaKey); + } else { + /* do private key operations */ + fn = (RSAOp)RSA_PrivateKeyOp; + if (privKey) { + /* convert NSSLOWKeyPrivateKey to RSAPrivateKey */ + rsaKey = (void *)(&privKey->u.rsa); + } + PORT_Assert(rsaKey); + } + } + + memset(buf, 1, sizeof buf); + rv = fn(rsaKey, buf2, buf); + if (rv != SECSuccess) { + PRErrorCode errNum; + const char * errStr = NULL; + + errNum = PORT_GetError(); + if (errNum) + errStr = SECU_Strerror(errNum); + else + errNum = rv; + if (!errStr) + errStr = "(null)"; + fprintf(stderr, "Error in RSA operation: %d : %s\n", errNum, errStr); + exit(1); + } + + threadsArr = (PRThread**)PORT_Alloc(threadNum*sizeof(PRThread*)); + runDataArr = (ThreadRunData**)PORT_Alloc(threadNum*sizeof(ThreadRunData*)); + timeCtx = CreateTimingContext(); + TimingBegin(timeCtx, PR_Now()); + for (i = 0;i < threadNum;i++) { + runDataArr[i] = (ThreadRunData*)PORT_Alloc(sizeof(ThreadRunData)); + runDataArr[i]->fn = fn; + runDataArr[i]->buf = buf; + runDataArr[i]->doIters = &doIters; + runDataArr[i]->rsaKey = rsaKey; + runDataArr[i]->seconds = seconds; + runDataArr[i]->iters = iters; + threadsArr[i] = + PR_CreateThread(PR_USER_THREAD, + ThreadExecFunction, + (void*) runDataArr[i], + PR_PRIORITY_NORMAL, + PR_GLOBAL_THREAD, + PR_JOINABLE_THREAD, + 0); + } + iters = 0; + calcThreads = 0; + for (i = 0;i < threadNum;i++, calcThreads++) + { + PR_JoinThread(threadsArr[i]); + if (runDataArr[i]->status != SECSuccess) { + const char * errStr = SECU_Strerror(runDataArr[i]->errNum); + fprintf(stderr, "Thread %d: Error in RSA operation: %d : %s\n", + i, runDataArr[i]->errNum, errStr); + calcThreads -= 1; + } else { + iters += runDataArr[i]->iterRes; + } + PORT_Free((void*)runDataArr[i]); + } + PORT_Free(runDataArr); + PORT_Free(threadsArr); + + TimingEnd(timeCtx, PR_Now()); + + printf("%ld iterations in %s\n", + iters, TimingGenerateString(timeCtx)); + printf("%.2f operations/s .\n", ((double)(iters)*(double)1000000.0) / + (double)timeCtx->interval ); + TimingDivide(timeCtx, iters); + printf("one operation every %s\n", TimingGenerateString(timeCtx)); + + if (pubHighKey) { + SECKEY_DestroyPublicKey(pubHighKey); + } + + if (privHighKey) { + SECKEY_DestroyPrivateKey(privHighKey); + } + + if (cert) { + CERT_DestroyCertificate(cert); + } + + if (NSS_Shutdown() != SECSuccess) { + exit(1); + } + + return 0; +} |