fixup commit for tag 'NSSCKBI_1_79_RTM'NSSCKBI_1_79_RTM

4 files changed, 0 insertions, 1173 deletions

diff --git a/security/nss/cmd/rsaperf/Makefile b/security/nss/cmd/rsaperf/Makefile
deleted file mode 100644
index 7df60581b..000000000
--- a/security/nss/cmd/rsaperf/Makefile
+++ /dev/null
@@ -1,78 +0,0 @@
-#! 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/security/nss/cmd/rsaperf/defkey.c b/security/nss/cmd/rsaperf/defkey.c
deleted file mode 100644
index 1cc04c785..000000000
--- a/security/nss/cmd/rsaperf/defkey.c
+++ /dev/null
@@ -1,325 +0,0 @@
-/* ***** 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/security/nss/cmd/rsaperf/manifest.mn b/security/nss/cmd/rsaperf/manifest.mn
deleted file mode 100644
index 2c820e3ce..000000000
--- a/security/nss/cmd/rsaperf/manifest.mn
+++ /dev/null
@@ -1,56 +0,0 @@
-# 
-# ***** 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/security/nss/cmd/rsaperf/rsaperf.c b/security/nss/cmd/rsaperf/rsaperf.c
deleted file mode 100644
index 78b707255..000000000
--- a/security/nss/cmd/rsaperf/rsaperf.c
+++ /dev/null
@@ -1,714 +0,0 @@
-/* ***** 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;
-}