开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
fipstest.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：41k
源码类别：

CA认证

开发平台：

WINDOWS

fipstest.c：源码内容
  1. /*
  2.  * PKCS #11 FIPS Power-Up Self Test.
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public
  5.  * License Version 1.1 (the "License"); you may not use this file
  6.  * except in compliance with the License. You may obtain a copy of
  7.  * the License at http://www.mozilla.org/MPL/
  8.  * 
  9.  * Software distributed under the License is distributed on an "AS
  10.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  11.  * implied. See the License for the specific language governing
  12.  * rights and limitations under the License.
  13.  * 
  14.  * The Original Code is the Netscape security libraries.
  15.  * 
  16.  * The Initial Developer of the Original Code is Netscape
  17.  * Communications Corporation.  Portions created by Netscape are 
  18.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  19.  * Rights Reserved.
  20.  * 
  21.  * Contributor(s):
  22.  * 
  23.  * Alternatively, the contents of this file may be used under the
  24.  * terms of the GNU General Public License Version 2 or later (the
  25.  * "GPL"), in which case the provisions of the GPL are applicable 
  26.  * instead of those above.  If you wish to allow use of your 
  27.  * version of this file only under the terms of the GPL and not to
  28.  * allow others to use your version of this file under the MPL,
  29.  * indicate your decision by deleting the provisions above and
  30.  * replace them with the notice and other provisions required by
  31.  * the GPL.  If you do not delete the provisions above, a recipient
  32.  * may use your version of this file under either the MPL or the
  33.  * GPL.
  34.  *
  35.  * $Id: fipstest.c,v 1.1 2000/03/31 19:25:43 relyea%netscape.com Exp $
  36.  */
  38. #include "softoken.h"   /* Required for RC2-ECB, RC2-CBC, RC4, DES-ECB,  */
  39.                         /*              DES-CBC, DES3-ECB, DES3-CBC, RSA */
  40.                         /*              and DSA.                         */
  41. #include "seccomon.h"   /* Required for RSA and DSA. */
  42. #include "keylow.h"     /* Required for RSA and DSA. */
  43. #include "pkcs11.h"     /* Required for PKCS #11. */
  44. #include "secerr.h"
  46. /* FIPS preprocessor directives for RC2-ECB and RC2-CBC.        */
  47. #define FIPS_RC2_KEY_LENGTH                      5  /*  40-bits */
  48. #define FIPS_RC2_ENCRYPT_LENGTH                  8  /*  64-bits */
  49. #define FIPS_RC2_DECRYPT_LENGTH                  8  /*  64-bits */
  52. /* FIPS preprocessor directives for RC4.                        */
  53. #define FIPS_RC4_KEY_LENGTH                      5  /*  40-bits */
  54. #define FIPS_RC4_ENCRYPT_LENGTH                  8  /*  64-bits */
  55. #define FIPS_RC4_DECRYPT_LENGTH                  8  /*  64-bits */
  58. /* FIPS preprocessor directives for DES-ECB and DES-CBC.        */
  59. #define FIPS_DES_ENCRYPT_LENGTH                  8  /*  64-bits */
  60. #define FIPS_DES_DECRYPT_LENGTH                  8  /*  64-bits */
  63. /* FIPS preprocessor directives for DES3-CBC and DES3-ECB.      */
  64. #define FIPS_DES3_ENCRYPT_LENGTH                 8  /*  64-bits */
  65. #define FIPS_DES3_DECRYPT_LENGTH                 8  /*  64-bits */
  68. /* FIPS preprocessor directives for MD2.                        */
  69. #define FIPS_MD2_HASH_MESSAGE_LENGTH            64  /* 512-bits */
  72. /* FIPS preprocessor directives for MD5.                        */
  73. #define FIPS_MD5_HASH_MESSAGE_LENGTH            64  /* 512-bits */
  76. /* FIPS preprocessor directives for SHA-1.                      */
  77. #define FIPS_SHA1_HASH_MESSAGE_LENGTH           64  /* 512-bits */
  80. /* FIPS preprocessor directives for RSA.                        */
  81. #define FIPS_RSA_TYPE                           siBuffer
  82. #define FIPS_RSA_PUBLIC_EXPONENT_LENGTH          1  /*   8-bits */
  83. #define FIPS_RSA_PRIVATE_VERSION_LENGTH          1  /*   8-bits */
  84. #define FIPS_RSA_MESSAGE_LENGTH                 16  /* 128-bits */
  85. #define FIPS_RSA_COEFFICIENT_LENGTH             32  /* 256-bits */
  86. #define FIPS_RSA_PRIME0_LENGTH                  33  /* 264-bits */
  87. #define FIPS_RSA_PRIME1_LENGTH                  33  /* 264-bits */
  88. #define FIPS_RSA_EXPONENT0_LENGTH               33  /* 264-bits */
  89. #define FIPS_RSA_EXPONENT1_LENGTH               33  /* 264-bits */
  90. #define FIPS_RSA_PRIVATE_EXPONENT_LENGTH        64  /* 512-bits */
  91. #define FIPS_RSA_ENCRYPT_LENGTH                 64  /* 512-bits */
  92. #define FIPS_RSA_DECRYPT_LENGTH                 64  /* 512-bits */
  93. #define FIPS_RSA_CRYPTO_LENGTH                  64  /* 512-bits */
  94. #define FIPS_RSA_SIGNATURE_LENGTH               64  /* 512-bits */
  95. #define FIPS_RSA_MODULUS_LENGTH                 65  /* 520-bits */
  98. /* FIPS preprocessor directives for DSA.                        */
  99. #define FIPS_DSA_TYPE                           siBuffer
  100. #define FIPS_DSA_DIGEST_LENGTH                  20  /* 160-bits */
  101. #define FIPS_DSA_SUBPRIME_LENGTH                20  /* 160-bits */
  102. #define FIPS_DSA_SIGNATURE_LENGTH               40  /* 320-bits */
  103. #define FIPS_DSA_PRIME_LENGTH                   64  /* 512-bits */
  104. #define FIPS_DSA_BASE_LENGTH                    64  /* 512-bits */
  106. static CK_RV
  107. pk11_fips_RC2_PowerUpSelfTest( void )
  108. {
  109.     /* RC2 Known Key (40-bits). */
  110.     static PRUint8 rc2_known_key[] = { "RSARC" };
  112.     /* RC2-CBC Known Initialization Vector (64-bits). */
  113.     static PRUint8 rc2_cbc_known_initialization_vector[] = {"Security"};
  115.     /* RC2 Known Plaintext (64-bits). */
  116.     static PRUint8 rc2_ecb_known_plaintext[] = {"Netscape"};
  117.     static PRUint8 rc2_cbc_known_plaintext[] = {"Netscape"};
  119.     /* RC2 Known Ciphertext (64-bits). */
  120.     static PRUint8 rc2_ecb_known_ciphertext[] = {
  121.   0x1a,0x71,0x33,0x54,0x8d,0x5c,0xd2,0x30};
  122.     static PRUint8 rc2_cbc_known_ciphertext[] = {
  123.   0xff,0x41,0xdb,0x94,0x8a,0x4c,0x33,0xb3};
  125.     /* RC2 variables. */
  126.     PRUint8        rc2_computed_ciphertext[FIPS_RC2_ENCRYPT_LENGTH];
  127.     PRUint8        rc2_computed_plaintext[FIPS_RC2_DECRYPT_LENGTH];
  128.     RC2Context *   rc2_context;
  129.     unsigned int   rc2_bytes_encrypted;
  130.     unsigned int   rc2_bytes_decrypted;
  131.     SECStatus      rc2_status;
  134.     /******************************************************/
  135.     /* RC2-ECB Single-Round Known Answer Encryption Test: */
  136.     /******************************************************/
  138.     rc2_context = RC2_CreateContext( rc2_known_key, FIPS_RC2_KEY_LENGTH,
  139.                                      NULL, NSS_RC2,
  140.                                      FIPS_RC2_KEY_LENGTH );
  142.     if( rc2_context == NULL )
  143.         return( CKR_HOST_MEMORY );
  145.     rc2_status = RC2_Encrypt( rc2_context, rc2_computed_ciphertext,
  146.                               &rc2_bytes_encrypted, FIPS_RC2_ENCRYPT_LENGTH,
  147.                               rc2_ecb_known_plaintext,
  148.                               FIPS_RC2_DECRYPT_LENGTH );
  150.     RC2_DestroyContext( rc2_context, PR_TRUE );
  152.     if( ( rc2_status != SECSuccess ) ||
  153.         ( rc2_bytes_encrypted != FIPS_RC2_ENCRYPT_LENGTH ) ||
  154.         ( PORT_Memcmp( rc2_computed_ciphertext, rc2_ecb_known_ciphertext,
  155.                        FIPS_RC2_ENCRYPT_LENGTH ) != 0 ) )
  156.         return( CKR_DEVICE_ERROR );
  159.     /******************************************************/
  160.     /* RC2-ECB Single-Round Known Answer Decryption Test: */
  161.     /******************************************************/
  163.     rc2_context = RC2_CreateContext( rc2_known_key, FIPS_RC2_KEY_LENGTH,
  164.                                      NULL, NSS_RC2,
  165.                                      FIPS_RC2_KEY_LENGTH );
  167.     if( rc2_context == NULL )
  168.         return( CKR_HOST_MEMORY );
  170.     rc2_status = RC2_Decrypt( rc2_context, rc2_computed_plaintext,
  171.                               &rc2_bytes_decrypted, FIPS_RC2_DECRYPT_LENGTH,
  172.                               rc2_ecb_known_ciphertext,
  173.                               FIPS_RC2_ENCRYPT_LENGTH );
  175.     RC2_DestroyContext( rc2_context, PR_TRUE );
  177.     if( ( rc2_status != SECSuccess ) ||
  178.         ( rc2_bytes_decrypted != FIPS_RC2_DECRYPT_LENGTH ) ||
  179.         ( PORT_Memcmp( rc2_computed_plaintext, rc2_ecb_known_plaintext,
  180.                        FIPS_RC2_DECRYPT_LENGTH ) != 0 ) )
  181.         return( CKR_DEVICE_ERROR );
  184.     /******************************************************/
  185.     /* RC2-CBC Single-Round Known Answer Encryption Test: */
  186.     /******************************************************/
  188.     rc2_context = RC2_CreateContext( rc2_known_key, FIPS_RC2_KEY_LENGTH,
  189.                                      rc2_cbc_known_initialization_vector,
  190.                                      NSS_RC2_CBC, FIPS_RC2_KEY_LENGTH );
  192.     if( rc2_context == NULL )
  193.         return( CKR_HOST_MEMORY );
  195.     rc2_status = RC2_Encrypt( rc2_context, rc2_computed_ciphertext,
  196.                               &rc2_bytes_encrypted, FIPS_RC2_ENCRYPT_LENGTH,
  197.                               rc2_cbc_known_plaintext,
  198.                               FIPS_RC2_DECRYPT_LENGTH );
  200.     RC2_DestroyContext( rc2_context, PR_TRUE );
  202.     if( ( rc2_status != SECSuccess ) ||
  203.         ( rc2_bytes_encrypted != FIPS_RC2_ENCRYPT_LENGTH ) ||
  204.         ( PORT_Memcmp( rc2_computed_ciphertext, rc2_cbc_known_ciphertext,
  205.                        FIPS_RC2_ENCRYPT_LENGTH ) != 0 ) )
  206.         return( CKR_DEVICE_ERROR );
  209.     /******************************************************/
  210.     /* RC2-CBC Single-Round Known Answer Decryption Test: */
  211.     /******************************************************/
  213.     rc2_context = RC2_CreateContext( rc2_known_key, FIPS_RC2_KEY_LENGTH,
  214.                                      rc2_cbc_known_initialization_vector,
  215.                                      NSS_RC2_CBC, FIPS_RC2_KEY_LENGTH );
  217.     if( rc2_context == NULL )
  218.         return( CKR_HOST_MEMORY );
  220.     rc2_status = RC2_Decrypt( rc2_context, rc2_computed_plaintext,
  221.                               &rc2_bytes_decrypted, FIPS_RC2_DECRYPT_LENGTH,
  222.                               rc2_cbc_known_ciphertext,
  223.                               FIPS_RC2_ENCRYPT_LENGTH );
  225.     RC2_DestroyContext( rc2_context, PR_TRUE );
  227.     if( ( rc2_status != SECSuccess ) ||
  228.         ( rc2_bytes_decrypted != FIPS_RC2_DECRYPT_LENGTH ) ||
  229.         ( PORT_Memcmp( rc2_computed_plaintext, rc2_ecb_known_plaintext,
  230.                        FIPS_RC2_DECRYPT_LENGTH ) != 0 ) )
  231.         return( CKR_DEVICE_ERROR );
  233.     return( CKR_OK );
  234. }
  237. static CK_RV
  238. pk11_fips_RC4_PowerUpSelfTest( void )
  239. {
  240.     /* RC4 Known Key (40-bits). */
  241.     static PRUint8 rc4_known_key[] = { "RSARC" };
  243.     /* RC4 Known Plaintext (64-bits). */
  244.     static PRUint8 rc4_known_plaintext[] = { "Netscape" };
  246.     /* RC4 Known Ciphertext (64-bits). */
  247.     static PRUint8 rc4_known_ciphertext[] = {
  248. 0x29,0x33,0xc7,0x9a,0x9d,0x6c,0x09,0xdd};
  250.     /* RC4 variables. */
  251.     PRUint8        rc4_computed_ciphertext[FIPS_RC4_ENCRYPT_LENGTH];
  252.     PRUint8        rc4_computed_plaintext[FIPS_RC4_DECRYPT_LENGTH];
  253.     RC4Context *   rc4_context;
  254.     unsigned int   rc4_bytes_encrypted;
  255.     unsigned int   rc4_bytes_decrypted;
  256.     SECStatus      rc4_status;
  259.     /**************************************************/
  260.     /* RC4 Single-Round Known Answer Encryption Test: */
  261.     /**************************************************/
  263.     rc4_context = RC4_CreateContext( rc4_known_key, FIPS_RC4_KEY_LENGTH );
  265.     if( rc4_context == NULL )
  266.         return( CKR_HOST_MEMORY );
  268.     rc4_status = RC4_Encrypt( rc4_context, rc4_computed_ciphertext,
  269.                               &rc4_bytes_encrypted, FIPS_RC4_ENCRYPT_LENGTH,
  270.                               rc4_known_plaintext, FIPS_RC4_DECRYPT_LENGTH );
  272.     RC4_DestroyContext( rc4_context, PR_TRUE );
  274.     if( ( rc4_status != SECSuccess ) ||
  275.         ( rc4_bytes_encrypted != FIPS_RC4_ENCRYPT_LENGTH ) ||
  276.         ( PORT_Memcmp( rc4_computed_ciphertext, rc4_known_ciphertext,
  277.                        FIPS_RC4_ENCRYPT_LENGTH ) != 0 ) )
  278.         return( CKR_DEVICE_ERROR );
  281.     /**************************************************/
  282.     /* RC4 Single-Round Known Answer Decryption Test: */
  283.     /**************************************************/
  285.     rc4_context = RC4_CreateContext( rc4_known_key, FIPS_RC4_KEY_LENGTH );
  287.     if( rc4_context == NULL )
  288.         return( CKR_HOST_MEMORY );
  290.     rc4_status = RC4_Decrypt( rc4_context, rc4_computed_plaintext,
  291.                               &rc4_bytes_decrypted, FIPS_RC4_DECRYPT_LENGTH,
  292.                               rc4_known_ciphertext, FIPS_RC4_ENCRYPT_LENGTH );
  294.     RC4_DestroyContext( rc4_context, PR_TRUE );
  296.     if( ( rc4_status != SECSuccess ) ||
  297.         ( rc4_bytes_decrypted != FIPS_RC4_DECRYPT_LENGTH ) ||
  298.         ( PORT_Memcmp( rc4_computed_plaintext, rc4_known_plaintext,
  299.                        FIPS_RC4_DECRYPT_LENGTH ) != 0 ) )
  300.         return( CKR_DEVICE_ERROR );
  302.     return( CKR_OK );
  303. }
  306. static CK_RV
  307. pk11_fips_DES_PowerUpSelfTest( void )
  308. {
  309.     /* DES Known Key (56-bits). */
  310.     static PRUint8 des_known_key[] = { "ANSI DES" };
  312.     /* DES-CBC Known Initialization Vector (64-bits). */
  313.     static PRUint8 des_cbc_known_initialization_vector[] = { "Security" };
  315.     /* DES Known Plaintext (64-bits). */
  316.     static PRUint8 des_ecb_known_plaintext[] = { "Netscape" };
  317.     static PRUint8 des_cbc_known_plaintext[] = { "Netscape" };
  319.     /* DES Known Ciphertext (64-bits). */
  320.     static PRUint8 des_ecb_known_ciphertext[] = {
  321.        0x26,0x14,0xe9,0xc3,0x28,0x80,0x50,0xb0};
  322.     static PRUint8 des_cbc_known_ciphertext[]  = {
  323.        0x5e,0x95,0x94,0x5d,0x76,0xa2,0xd3,0x7d};
  325.     /* DES variables. */
  326.     PRUint8        des_computed_ciphertext[FIPS_DES_ENCRYPT_LENGTH];
  327.     PRUint8        des_computed_plaintext[FIPS_DES_DECRYPT_LENGTH];
  328.     DESContext *   des_context;
  329.     unsigned int   des_bytes_encrypted;
  330.     unsigned int   des_bytes_decrypted;
  331.     SECStatus      des_status;
  334.     /******************************************************/
  335.     /* DES-ECB Single-Round Known Answer Encryption Test: */
  336.     /******************************************************/
  338.     des_context = DES_CreateContext( des_known_key, NULL, NSS_DES, PR_TRUE );
  340.     if( des_context == NULL )
  341.         return( CKR_HOST_MEMORY );
  343.     des_status = DES_Encrypt( des_context, des_computed_ciphertext,
  344.                               &des_bytes_encrypted, FIPS_DES_ENCRYPT_LENGTH,
  345.                               des_ecb_known_plaintext,
  346.                               FIPS_DES_DECRYPT_LENGTH );
  348.     DES_DestroyContext( des_context, PR_TRUE );
  350.     if( ( des_status != SECSuccess ) ||
  351.         ( des_bytes_encrypted != FIPS_DES_ENCRYPT_LENGTH ) ||
  352.         ( PORT_Memcmp( des_computed_ciphertext, des_ecb_known_ciphertext,
  353.                        FIPS_DES_ENCRYPT_LENGTH ) != 0 ) )
  354.         return( CKR_DEVICE_ERROR );
  357.     /******************************************************/
  358.     /* DES-ECB Single-Round Known Answer Decryption Test: */
  359.     /******************************************************/
  361.     des_context = DES_CreateContext( des_known_key, NULL, NSS_DES, PR_FALSE );
  363.     if( des_context == NULL )
  364.         return( CKR_HOST_MEMORY );
  366.     des_status = DES_Decrypt( des_context, des_computed_plaintext,
  367.                               &des_bytes_decrypted, FIPS_DES_DECRYPT_LENGTH,
  368.                               des_ecb_known_ciphertext,
  369.                               FIPS_DES_ENCRYPT_LENGTH );
  371.     DES_DestroyContext( des_context, PR_TRUE );
  373.     if( ( des_status != SECSuccess ) ||
  374.         ( des_bytes_decrypted != FIPS_DES_DECRYPT_LENGTH ) ||
  375.         ( PORT_Memcmp( des_computed_plaintext, des_ecb_known_plaintext,
  376.                        FIPS_DES_DECRYPT_LENGTH ) != 0 ) )
  377.         return( CKR_DEVICE_ERROR );
  380.     /******************************************************/
  381.     /* DES-CBC Single-Round Known Answer Encryption Test. */
  382.     /******************************************************/
  384.     des_context = DES_CreateContext( des_known_key,
  385.                                      des_cbc_known_initialization_vector,
  386.                                      NSS_DES_CBC, PR_TRUE );
  388.     if( des_context == NULL )
  389.         return( CKR_HOST_MEMORY );
  391.     des_status = DES_Encrypt( des_context, des_computed_ciphertext,
  392.                               &des_bytes_encrypted, FIPS_DES_ENCRYPT_LENGTH,
  393.                               des_cbc_known_plaintext,
  394.                               FIPS_DES_DECRYPT_LENGTH );
  396.     DES_DestroyContext( des_context, PR_TRUE );
  398.     if( ( des_status != SECSuccess ) ||
  399.         ( des_bytes_encrypted != FIPS_DES_ENCRYPT_LENGTH ) ||
  400.         ( PORT_Memcmp( des_computed_ciphertext, des_cbc_known_ciphertext,
  401.                        FIPS_DES_ENCRYPT_LENGTH ) != 0 ) )
  402.         return( CKR_DEVICE_ERROR );
  405.     /******************************************************/
  406.     /* DES-CBC Single-Round Known Answer Decryption Test. */
  407.     /******************************************************/
  409.     des_context = DES_CreateContext( des_known_key,
  410.                                      des_cbc_known_initialization_vector,
  411.                                      NSS_DES_CBC, PR_FALSE );
  413.     if( des_context == NULL )
  414.         return( CKR_HOST_MEMORY );
  416.     des_status = DES_Decrypt( des_context, des_computed_plaintext,
  417.                               &des_bytes_decrypted, FIPS_DES_DECRYPT_LENGTH,
  418.                               des_cbc_known_ciphertext,
  419.                               FIPS_DES_ENCRYPT_LENGTH );
  421.     DES_DestroyContext( des_context, PR_TRUE );
  423.     if( ( des_status != SECSuccess ) ||
  424.         ( des_bytes_decrypted != FIPS_DES_DECRYPT_LENGTH ) ||
  425.         ( PORT_Memcmp( des_computed_plaintext, des_cbc_known_plaintext,
  426.                        FIPS_DES_DECRYPT_LENGTH ) != 0 ) )
  427.         return( CKR_DEVICE_ERROR );
  429.     return( CKR_OK );
  430. }
  433. static CK_RV
  434. pk11_fips_DES3_PowerUpSelfTest( void )
  435. {
  436.     /* DES3 Known Key (56-bits). */
  437.     static PRUint8 des3_known_key[] = { "ANSI Triple-DES Key Data" };
  439.     /* DES3-CBC Known Initialization Vector (64-bits). */
  440.     static PRUint8 des3_cbc_known_initialization_vector[] = { "Security" };
  442.     /* DES3 Known Plaintext (64-bits). */
  443.     static PRUint8 des3_ecb_known_plaintext[] = { "Netscape" };
  444.     static PRUint8 des3_cbc_known_plaintext[] = { "Netscape" };
  446.     /* DES3 Known Ciphertext (64-bits). */
  447.     static PRUint8 des3_ecb_known_ciphertext[] = {
  448.    0x55,0x8e,0xad,0x3c,0xee,0x49,0x69,0xbe};
  449.     static PRUint8 des3_cbc_known_ciphertext[] = {
  450.    0x43,0xdc,0x6a,0xc1,0xaf,0xa6,0x32,0xf5};
  452.     /* DES3 variables. */
  453.     PRUint8        des3_computed_ciphertext[FIPS_DES3_ENCRYPT_LENGTH];
  454.     PRUint8        des3_computed_plaintext[FIPS_DES3_DECRYPT_LENGTH];
  455.     DESContext *   des3_context;
  456.     unsigned int   des3_bytes_encrypted;
  457.     unsigned int   des3_bytes_decrypted;
  458.     SECStatus      des3_status;
  461.     /*******************************************************/
  462.     /* DES3-ECB Single-Round Known Answer Encryption Test. */
  463.     /*******************************************************/
  465.     des3_context = DES_CreateContext( des3_known_key, NULL,
  466.                                      NSS_DES_EDE3, PR_TRUE );
  468.     if( des3_context == NULL )
  469.         return( CKR_HOST_MEMORY );
  471.     des3_status = DES_Encrypt( des3_context, des3_computed_ciphertext,
  472.                                &des3_bytes_encrypted, FIPS_DES3_ENCRYPT_LENGTH,
  473.                                des3_ecb_known_plaintext,
  474.                                FIPS_DES3_DECRYPT_LENGTH );
  476.     DES_DestroyContext( des3_context, PR_TRUE );
  478.     if( ( des3_status != SECSuccess ) ||
  479.         ( des3_bytes_encrypted != FIPS_DES3_ENCRYPT_LENGTH ) ||
  480.         ( PORT_Memcmp( des3_computed_ciphertext, des3_ecb_known_ciphertext,
  481.                        FIPS_DES3_ENCRYPT_LENGTH ) != 0 ) )
  482.         return( CKR_DEVICE_ERROR );
  485.     /*******************************************************/
  486.     /* DES3-ECB Single-Round Known Answer Decryption Test. */
  487.     /*******************************************************/
  489.     des3_context = DES_CreateContext( des3_known_key, NULL,
  490.                                      NSS_DES_EDE3, PR_FALSE );
  492.     if( des3_context == NULL )
  493.         return( CKR_HOST_MEMORY );
  495.     des3_status = DES_Decrypt( des3_context, des3_computed_plaintext,
  496.                                &des3_bytes_decrypted, FIPS_DES3_DECRYPT_LENGTH,
  497.                                des3_ecb_known_ciphertext,
  498.                                FIPS_DES3_ENCRYPT_LENGTH );
  500.     DES_DestroyContext( des3_context, PR_TRUE );
  502.     if( ( des3_status != SECSuccess ) ||
  503.         ( des3_bytes_decrypted != FIPS_DES3_DECRYPT_LENGTH ) ||
  504.         ( PORT_Memcmp( des3_computed_plaintext, des3_ecb_known_plaintext,
  505.                        FIPS_DES3_DECRYPT_LENGTH ) != 0 ) )
  506.         return( CKR_DEVICE_ERROR );
  509.     /*******************************************************/
  510.     /* DES3-CBC Single-Round Known Answer Encryption Test. */
  511.     /*******************************************************/
  513.     des3_context = DES_CreateContext( des3_known_key,
  514.                                       des3_cbc_known_initialization_vector,
  515.                                       NSS_DES_EDE3_CBC, PR_TRUE );
  517.     if( des3_context == NULL )
  518.         return( CKR_HOST_MEMORY );
  520.     des3_status = DES_Encrypt( des3_context, des3_computed_ciphertext,
  521.                                &des3_bytes_encrypted, FIPS_DES3_ENCRYPT_LENGTH,
  522.                                des3_cbc_known_plaintext,
  523.                                FIPS_DES3_DECRYPT_LENGTH );
  525.     DES_DestroyContext( des3_context, PR_TRUE );
  527.     if( ( des3_status != SECSuccess ) ||
  528.         ( des3_bytes_encrypted != FIPS_DES3_ENCRYPT_LENGTH ) ||
  529.         ( PORT_Memcmp( des3_computed_ciphertext, des3_cbc_known_ciphertext,
  530.                        FIPS_DES3_ENCRYPT_LENGTH ) != 0 ) )
  531.         return( CKR_DEVICE_ERROR );
  534.     /*******************************************************/
  535.     /* DES3-CBC Single-Round Known Answer Decryption Test. */
  536.     /*******************************************************/
  538.     des3_context = DES_CreateContext( des3_known_key,
  539.                                       des3_cbc_known_initialization_vector,
  540.                                       NSS_DES_EDE3_CBC, PR_FALSE );
  542.     if( des3_context == NULL )
  543.         return( CKR_HOST_MEMORY );
  545.     des3_status = DES_Decrypt( des3_context, des3_computed_plaintext,
  546.                                &des3_bytes_decrypted, FIPS_DES3_DECRYPT_LENGTH,
  547.                                des3_cbc_known_ciphertext,
  548.                                FIPS_DES3_ENCRYPT_LENGTH );
  550.     DES_DestroyContext( des3_context, PR_TRUE );
  552.     if( ( des3_status != SECSuccess ) ||
  553.         ( des3_bytes_decrypted != FIPS_DES3_DECRYPT_LENGTH ) ||
  554.         ( PORT_Memcmp( des3_computed_plaintext, des3_cbc_known_plaintext,
  555.                        FIPS_DES3_DECRYPT_LENGTH ) != 0 ) )
  556.         return( CKR_DEVICE_ERROR );
  558.     return( CKR_OK );
  559. }
  562. static CK_RV
  563. pk11_fips_MD2_PowerUpSelfTest( void )
  564. {
  565.     /* MD2 Known Hash Message (512-bits). */
  566.     static PRUint8 md2_known_hash_message[] = {
  567. "The test message for the MD2, MD5, and SHA-1 hashing algorithms." };
  569.     /* MD2 Known Digest Message (128-bits). */
  570.     static PRUint8 md2_known_digest[]  = {
  571.    0x41,0x5a,0x12,0xb2,0x3f,0x28,0x97,0x17,
  572.    0x0c,0x71,0x4e,0xcc,0x40,0xc8,0x1d,0x1b};
  574.     /* MD2 variables. */
  575.     MD2Context * md2_context;
  576.     unsigned int md2_bytes_hashed;
  577.     PRUint8      md2_computed_digest[MD2_LENGTH];
  580.     /***********************************************/
  581.     /* MD2 Single-Round Known Answer Hashing Test. */
  582.     /***********************************************/
  584.     md2_context = MD2_NewContext();
  586.     if( md2_context == NULL )
  587.         return( CKR_HOST_MEMORY );
  589.     MD2_Begin( md2_context );
  591.     MD2_Update( md2_context, md2_known_hash_message,
  592.                 FIPS_MD2_HASH_MESSAGE_LENGTH );
  594.     MD2_End( md2_context, md2_computed_digest, &md2_bytes_hashed, MD2_LENGTH );
  596.     MD2_DestroyContext( md2_context , PR_TRUE );
  598.     if( ( md2_bytes_hashed != MD2_LENGTH ) ||
  599.         ( PORT_Memcmp( md2_computed_digest, md2_known_digest,
  600.                        MD2_LENGTH ) != 0 ) )
  601.         return( CKR_DEVICE_ERROR );
  603.     return( CKR_OK );
  604. }
  607. static CK_RV
  608. pk11_fips_MD5_PowerUpSelfTest( void )
  609. {
  610.     /* MD5 Known Hash Message (512-bits). */
  611.     static PRUint8 md5_known_hash_message[] = {
  612. "The test message for the MD2, MD5, and SHA-1 hashing algorithms." };
  614.     /* MD5 Known Digest Message (128-bits). */
  615.     static PRUint8 md5_known_digest[]  = {
  616.    0x25,0xc8,0xc0,0x10,0xc5,0x6e,0x68,0x28,
  617.    0x28,0xa4,0xa5,0xd2,0x98,0x9a,0xea,0x2d};
  619.     /* MD5 variables. */
  620.     PRUint8        md5_computed_digest[MD5_LENGTH];
  621.     SECStatus      md5_status;
  624.     /***********************************************/
  625.     /* MD5 Single-Round Known Answer Hashing Test. */
  626.     /***********************************************/
  628.     md5_status = MD5_HashBuf( md5_computed_digest, md5_known_hash_message,
  629.                               FIPS_MD5_HASH_MESSAGE_LENGTH );
  631.     if( ( md5_status != SECSuccess ) ||
  632.         ( PORT_Memcmp( md5_computed_digest, md5_known_digest,
  633.                        MD5_LENGTH ) != 0 ) )
  634.         return( CKR_DEVICE_ERROR );
  636.     return( CKR_OK );
  637. }
  640. static CK_RV
  641. pk11_fips_SHA1_PowerUpSelfTest( void )
  642. {
  643.     /* SHA-1 Known Hash Message (512-bits). */
  644.     static PRUint8 sha1_known_hash_message[] = {
  645.  "The test message for the MD2, MD5, and SHA-1 hashing algorithms." };
  647.     /* SHA-1 Known Digest Message (160-bits). */
  648.     static PRUint8 sha1_known_digest[] = {
  649.        0x0a,0x6d,0x07,0xba,0x1e,0xbd,0x8a,0x1b,
  650.        0x72,0xf6,0xc7,0x22,0xf1,0x27,0x9f,0xf0,
  651.        0xe0,0x68,0x47,0x7a};
  653.     /* SHA-1 variables. */
  654.     PRUint8        sha1_computed_digest[SHA1_LENGTH];
  655.     SECStatus      sha1_status;
  658.     /*************************************************/
  659.     /* SHA-1 Single-Round Known Answer Hashing Test. */
  660.     /*************************************************/
  662.     sha1_status = SHA1_HashBuf( sha1_computed_digest, sha1_known_hash_message,
  663.                                 FIPS_SHA1_HASH_MESSAGE_LENGTH );
  665.     if( ( sha1_status != SECSuccess ) ||
  666.         ( PORT_Memcmp( sha1_computed_digest, sha1_known_digest,
  667.                        SHA1_LENGTH ) != 0 ) )
  668.         return( CKR_DEVICE_ERROR );
  670.     return( CKR_OK );
  671. }
  674. static CK_RV
  675. pk11_fips_RSA_PowerUpSelfTest( void )
  676. {
  677.     /* RSA Known Modulus used in both Public/Private Key Values (520-bits). */
  678.     static PRUint8 rsa_modulus[FIPS_RSA_MODULUS_LENGTH] = {
  679.                                  0x00,0xa1,0xe9,0x5e,0x66,0x88,0xe2,0xf2,
  680.                                  0x2b,0xe7,0x70,0x36,0x33,0xbc,0xeb,0x55,
  681.                                  0x55,0xf1,0x60,0x18,0x3c,0xfb,0xd2,0x79,
  682.                                  0xf6,0xc4,0xb8,0x09,0xe3,0x12,0xf6,0x63,
  683.                                  0x6d,0xc7,0x8e,0x19,0xc0,0x0e,0x10,0x78,
  684.                                  0xc1,0xfe,0x2a,0x41,0x74,0x2d,0xf7,0xc4,
  685.                                  0x69,0xa7,0x3c,0xbc,0x8a,0xc8,0x31,0x2b,
  686.                                  0x4f,0x60,0xf0,0xf1,0xec,0x5a,0x29,0xec,
  687.                                  0x6b};
  689.     /* RSA Known Public Key Values (8-bits). */
  690.     static PRUint8 rsa_public_exponent[] = { 0x03 };
  692.     /* RSA Known Private Key Values (version                 is   8-bits), */
  693.     /*                              (private exponent        is 512-bits), */
  694.     /*                              (private prime0          is 264-bits), */
  695.     /*                              (private prime1          is 264-bits), */
  696.     /*                              (private prime exponent0 is 264-bits), */
  697.     /*                              (private prime exponent1 is 264-bits), */
  698.     /*                          and (private coefficient     is 256-bits). */
  699.     static PRUint8 rsa_version[] = { 0x00 };
  700.     static PRUint8 rsa_private_exponent[FIPS_RSA_PRIVATE_EXPONENT_LENGTH] = {
  701.   0x6b,0xf0,0xe9,0x99,0xb0,0x97,0x4c,0x1d,
  702.   0x44,0xf5,0x79,0x77,0xd3,0x47,0x8e,0x39,
  703.   0x4b,0x95,0x65,0x7d,0xfd,0x36,0xfb,0xf9,
  704.   0xd8,0x7a,0xb1,0x42,0x0c,0xa4,0x42,0x48,
  705.   0x20,0x1c,0x6b,0x7d,0x5d,0xa3,0x58,0xd6,
  706.   0x95,0xd6,0x41,0xe3,0xd6,0x73,0xad,0xdb,
  707.   0x3b,0x89,0x00,0x8a,0xcd,0x1d,0xb9,0x06,
  708.   0xac,0xac,0x0e,0x02,0x72,0x1c,0xf8,0xab };
  709.     static PRUint8 rsa_prime0[FIPS_RSA_PRIME0_LENGTH]   = {
  710.       0x00,0xd2,0x2c,0x9d,0xef,0x7c,0x8f,0x58,
  711.       0x93,0x19,0xa1,0x77,0x0e,0x38,0x3e,0x85,
  712.       0xb4,0xaf,0xcc,0x99,0xa5,0x43,0xbf,0x97,
  713.       0xdc,0x46,0xb8,0x3f,0x6e,0x85,0x18,0x00,
  714.       0x81};
  715.     static PRUint8 rsa_prime1[FIPS_RSA_PRIME1_LENGTH]   = {
  716.       0x00,0xc5,0x36,0xda,0x94,0x85,0x0c,0x1a,
  717.       0xed,0x03,0xc7,0x67,0x90,0x34,0x0b,0xb9,
  718.       0xec,0x1e,0x22,0xa2,0x15,0x50,0xc4,0xfd,
  719.       0xe9,0x17,0x36,0x9d,0x7a,0x29,0xe6,0x76,
  720.       0xeb};
  721.     static PRUint8 rsa_exponent0[FIPS_RSA_EXPONENT0_LENGTH] = {
  722.  0x00,0x8c,0x1d,0xbe,0x9f,0xa8,
  723.  0x5f,0x90,0x62,0x11,0x16,0x4f,
  724.  0x5e,0xd0,0x29,0xae,0x78,0x75,
  725.  0x33,0x11,0x18,0xd7,0xd5,0x0f,
  726.  0xe8,0x2f,0x25,0x7f,0x9f,0x03,
  727.  0x65,0x55,0xab};
  728.     static PRUint8 rsa_exponent1[FIPS_RSA_EXPONENT1_LENGTH] = {
  729.  0x00,0x83,0x79,0xe7,0x0d,0xae,
  730.  0x08,0x11,0xf3,0x57,0xda,0x45,
  731.  0x0a,0xcd,0x5d,0x26,0x9d,0x69,
  732.  0x6c,0x6c,0x0e,0x35,0xd8,0xa9,
  733.  0x46,0x0f,0x79,0xbe,0x51,0x71,
  734.  0x44,0x4f,0x47};
  735.     static PRUint8 rsa_coefficient[FIPS_RSA_COEFFICIENT_LENGTH] = {
  736.  0x54,0x8d,0xb8,0xdc,0x8b,0xde,0xbb,
  737.  0x08,0xc9,0x67,0xb7,0xa9,0x5f,0xa5,
  738.  0xc4,0x5e,0x67,0xaa,0xfe,0x1a,0x08,
  739.  0xeb,0x48,0x43,0xcb,0xb0,0xb9,0x38,
  740.  0x3a,0x31,0x39,0xde};
  743.     /* RSA Known Plaintext (512-bits). */
  744.     static PRUint8 rsa_known_plaintext[] = {
  745.                                          "Known plaintext utilized for RSA"
  746.                                          " Encryption and Decryption test." };
  748.     /* RSA Known Ciphertext (512-bits). */
  749.     static PRUint8 rsa_known_ciphertext[] = {
  750.       0x12,0x80,0x3a,0x53,0xee,0x93,0x81,0xa5,
  751.       0xf7,0x40,0xc5,0xb1,0xef,0xd9,0x27,0xaf,
  752.       0xef,0x4b,0x87,0x44,0x00,0xd0,0xda,0xcf,
  753.       0x10,0x57,0x4c,0xd5,0xc3,0xed,0x84,0xdc,
  754.       0x74,0x03,0x19,0x69,0x2c,0xd6,0x54,0x3e,
  755.       0xd2,0xe3,0x90,0xb6,0x67,0x91,0x2f,0x1f,
  756.       0x54,0x13,0x99,0x00,0x0b,0xfd,0x52,0x7f,
  757.       0xd8,0xc6,0xdb,0x8a,0xfe,0x06,0xf3,0xb1};
  759.     /* RSA Known Message (128-bits). */
  760.     static PRUint8 rsa_known_message[]  = { "Netscape Forever" };
  762.     /* RSA Known Signed Hash (512-bits). */
  763.     static PRUint8 rsa_known_signature[] = {
  764.      0x27,0x23,0xa6,0x71,0x57,0xc8,0x70,0x5f,
  765.      0x70,0x0e,0x06,0x7b,0x96,0x6a,0xaa,0x41,
  766.      0x6e,0xab,0x67,0x4b,0x5f,0x76,0xc4,0x53,
  767.      0x23,0xd7,0x57,0x7a,0x3a,0xbc,0x4c,0x27,
  768.      0x65,0xca,0xde,0x9f,0xd3,0x1d,0xa4,0x5a,
  769.      0xf9,0x8f,0xb2,0x05,0xa3,0x86,0xf9,0x66,
  770.      0x55,0x4c,0x68,0x50,0x66,0xa4,0xe9,0x17,
  771.      0x45,0x11,0xb8,0x1a,0xfc,0xbc,0x79,0x3b};
  774.     static RSAPublicKey    bl_public_key = { NULL, 
  775.       { FIPS_RSA_TYPE, rsa_modulus,         FIPS_RSA_MODULUS_LENGTH },
  776.       { FIPS_RSA_TYPE, rsa_public_exponent, FIPS_RSA_PUBLIC_EXPONENT_LENGTH }
  777.     };
  778.     static RSAPrivateKey   bl_private_key = { NULL,
  779.       { FIPS_RSA_TYPE, rsa_version,          FIPS_RSA_PRIVATE_VERSION_LENGTH },
  780.       { FIPS_RSA_TYPE, rsa_modulus,          FIPS_RSA_MODULUS_LENGTH },
  781.       { FIPS_RSA_TYPE, rsa_public_exponent,  FIPS_RSA_PUBLIC_EXPONENT_LENGTH },
  782.       { FIPS_RSA_TYPE, rsa_private_exponent, FIPS_RSA_PRIVATE_EXPONENT_LENGTH },
  783.       { FIPS_RSA_TYPE, rsa_prime0,           FIPS_RSA_PRIME0_LENGTH },
  784.       { FIPS_RSA_TYPE, rsa_prime1,           FIPS_RSA_PRIME1_LENGTH },
  785.       { FIPS_RSA_TYPE, rsa_exponent0,        FIPS_RSA_EXPONENT0_LENGTH },
  786.       { FIPS_RSA_TYPE, rsa_exponent1,        FIPS_RSA_EXPONENT1_LENGTH },
  787.       { FIPS_RSA_TYPE, rsa_coefficient,      FIPS_RSA_COEFFICIENT_LENGTH }
  788.     };
  790.     /* RSA variables. */
  791. #ifdef CREATE_TEMP_ARENAS
  792.     PLArenaPool *         rsa_public_arena;
  793.     PLArenaPool *         rsa_private_arena;
  794. #endif
  795.     SECKEYLowPublicKey *  rsa_public_key;
  796.     SECKEYLowPrivateKey * rsa_private_key;
  797.     unsigned int          rsa_bytes_signed;
  798.     SECStatus             rsa_status;
  800.     SECKEYLowPublicKey    low_public_key   = { NULL, rsaKey, };
  801.     SECKEYLowPrivateKey   low_private_key  = { NULL, rsaKey, };
  802.     PRUint8               rsa_computed_ciphertext[FIPS_RSA_ENCRYPT_LENGTH];
  803.     PRUint8               rsa_computed_plaintext[FIPS_RSA_DECRYPT_LENGTH];
  804.     PRUint8               rsa_computed_signature[FIPS_RSA_SIGNATURE_LENGTH];
  806.     /****************************************/
  807.     /* Compose RSA Public/Private Key Pair. */
  808.     /****************************************/
  810.     low_public_key.u.rsa  = bl_public_key;
  811.     low_private_key.u.rsa = bl_private_key;
  813.     rsa_public_key  = &low_public_key;
  814.     rsa_private_key = &low_private_key;
  816. #ifdef CREATE_TEMP_ARENAS
  817.     /* Create some space for the RSA public key. */
  818.     rsa_public_arena = PORT_NewArena( NSS_SOFTOKEN_DEFAULT_CHUNKSIZE );
  820.     if( rsa_public_arena == NULL ) {
  821.         PORT_SetError( SEC_ERROR_NO_MEMORY );
  822.         return( CKR_HOST_MEMORY );
  823.     }
  825.     /* Create some space for the RSA private key. */
  826.     rsa_private_arena = PORT_NewArena( NSS_SOFTOKEN_DEFAULT_CHUNKSIZE );
  828.     if( rsa_private_arena == NULL ) {
  829.         PORT_FreeArena( rsa_public_arena, PR_TRUE );
  830.         PORT_SetError( SEC_ERROR_NO_MEMORY );
  831.         return( CKR_HOST_MEMORY );
  832.     }
  834.     rsa_public_key->arena = rsa_public_arena;
  835.     rsa_private_key->arena = rsa_private_arena;
  836. #endif
  838.     /**************************************************/
  839.     /* RSA Single-Round Known Answer Encryption Test. */
  840.     /**************************************************/
  842.     /* Perform RSA Public Key Encryption. */
  843.     rsa_status = RSA_PublicKeyOp(&rsa_public_key->u.rsa, 
  844.                                  rsa_computed_ciphertext, rsa_known_plaintext);
  846.     if( ( rsa_status != SECSuccess ) ||
  847.         ( PORT_Memcmp( rsa_computed_ciphertext, rsa_known_ciphertext,
  848.                        FIPS_RSA_ENCRYPT_LENGTH ) != 0 ) )
  849.         goto rsa_loser;
  851.     /**************************************************/
  852.     /* RSA Single-Round Known Answer Decryption Test. */
  853.     /**************************************************/
  855.     /* Perform RSA Private Key Decryption. */
  856.     rsa_status = RSA_PrivateKeyOp(&rsa_private_key->u.rsa, 
  857.                                   rsa_computed_plaintext, rsa_known_ciphertext);
  859.     if( ( rsa_status != SECSuccess ) ||
  860.         ( PORT_Memcmp( rsa_computed_plaintext, rsa_known_plaintext,
  861.                        FIPS_RSA_DECRYPT_LENGTH ) != 0 ) )
  862.         goto rsa_loser;
  865.     /*************************************************/
  866.     /* RSA Single-Round Known Answer Signature Test. */
  867.     /*************************************************/
  869.     /* Perform RSA signature with the RSA private key. */
  870.     rsa_status = RSA_Sign( rsa_private_key, rsa_computed_signature,
  871.                            &rsa_bytes_signed,
  872.                            FIPS_RSA_SIGNATURE_LENGTH, rsa_known_message,
  873.                            FIPS_RSA_MESSAGE_LENGTH );
  875.     if( ( rsa_status != SECSuccess ) ||
  876.         ( rsa_bytes_signed != FIPS_RSA_SIGNATURE_LENGTH ) ||
  877.         ( PORT_Memcmp( rsa_computed_signature, rsa_known_signature,
  878.                        FIPS_RSA_SIGNATURE_LENGTH ) != 0 ) )
  879.         goto rsa_loser;
  882.     /****************************************************/
  883.     /* RSA Single-Round Known Answer Verification Test. */
  884.     /****************************************************/
  886.     /* Perform RSA verification with the RSA public key. */
  887.     rsa_status = RSA_CheckSign( rsa_public_key,
  888.                                 rsa_computed_signature,
  889.                                 FIPS_RSA_SIGNATURE_LENGTH,
  890.                                 rsa_known_message,
  891.                                 FIPS_RSA_MESSAGE_LENGTH );
  893.     if( rsa_status != SECSuccess )
  894.         goto rsa_loser;
  896.     /* Dispose of all RSA key material. */
  897.     SECKEY_LowDestroyPublicKey( rsa_public_key );
  898.     SECKEY_LowDestroyPrivateKey( rsa_private_key );
  900.     return( CKR_OK );
  903. rsa_loser:
  905.     SECKEY_LowDestroyPublicKey( rsa_public_key );
  906.     SECKEY_LowDestroyPrivateKey( rsa_private_key );
  908.     return( CKR_DEVICE_ERROR );
  909. }
  912. static CK_RV
  913. pk11_fips_DSA_PowerUpSelfTest( void )
  914. {
  915.     /* DSA Known P (512-bits), Q (160-bits), and G (512-bits) Values. */
  916.     static PRUint8 dsa_P[] = {
  917.                            0x8d,0xf2,0xa4,0x94,0x49,0x22,0x76,0xaa,
  918.                            0x3d,0x25,0x75,0x9b,0xb0,0x68,0x69,0xcb,
  919.                            0xea,0xc0,0xd8,0x3a,0xfb,0x8d,0x0c,0xf7,
  920.                            0xcb,0xb8,0x32,0x4f,0x0d,0x78,0x82,0xe5,
  921.                            0xd0,0x76,0x2f,0xc5,0xb7,0x21,0x0e,0xaf,
  922.                            0xc2,0xe9,0xad,0xac,0x32,0xab,0x7a,0xac,
  923.                            0x49,0x69,0x3d,0xfb,0xf8,0x37,0x24,0xc2,
  924.                            0xec,0x07,0x36,0xee,0x31,0xc8,0x02,0x91};
  925.     static PRUint8 dsa_Q[] = {
  926.                            0xc7,0x73,0x21,0x8c,0x73,0x7e,0xc8,0xee,
  927.                            0x99,0x3b,0x4f,0x2d,0xed,0x30,0xf4,0x8e,
  928.                            0xda,0xce,0x91,0x5f};
  929.     static PRUint8 dsa_G[] = {
  930.                            0x62,0x6d,0x02,0x78,0x39,0xea,0x0a,0x13,
  931.                            0x41,0x31,0x63,0xa5,0x5b,0x4c,0xb5,0x00,
  932.                            0x29,0x9d,0x55,0x22,0x95,0x6c,0xef,0xcb,
  933.                            0x3b,0xff,0x10,0xf3,0x99,0xce,0x2c,0x2e,
  934.                            0x71,0xcb,0x9d,0xe5,0xfa,0x24,0xba,0xbf,
  935.                            0x58,0xe5,0xb7,0x95,0x21,0x92,0x5c,0x9c,
  936.                            0xc4,0x2e,0x9f,0x6f,0x46,0x4b,0x08,0x8c,
  937.                            0xc5,0x72,0xaf,0x53,0xe6,0xd7,0x88,0x02};
  939.     /* DSA Known Random Values (known random key block       is 160-bits)  */
  940.     /*                     and (known random signature block is 160-bits). */
  941.     static PRUint8 dsa_known_random_key_block[] = {
  942.                                                       "Mozilla Rules World!"};
  943.     static PRUint8 dsa_known_random_signature_block[] = {
  944.                                                       "Random DSA Signature"};
  946.     /* DSA Known Digest (160-bits) */
  947.     static PRUint8 dsa_known_digest[] = { "DSA Signature Digest" };
  949.     /* DSA Known Signature (320-bits). */
  950.     static PRUint8 dsa_known_signature[] = {
  951.      0x39,0x0d,0x84,0xb1,0xf7,0x52,0x89,0xba,
  952.      0xec,0x1e,0xa8,0xe2,0x00,0x8e,0x37,0x8f,
  953.      0xc2,0xf5,0xf8,0x70,0x11,0xa8,0xc7,0x02,
  954.      0x0e,0x75,0xcf,0x6b,0x54,0x4a,0x52,0xe8,
  955.      0xd8,0x6d,0x4a,0xe8,0xee,0x56,0x8e,0x59};
  957.     /* DSA variables. */
  958.     DSAPrivateKey *        dsa_private_key;
  959.     SECStatus              dsa_status;
  960.     SECItem                dsa_signature_item;
  961.     SECItem                dsa_digest_item;
  962.     DSAPublicKey           dsa_public_key;
  963.     PRUint8                dsa_computed_signature[FIPS_DSA_SIGNATURE_LENGTH];
  964.     static PQGParams       dsa_pqg = { NULL,
  965.     { FIPS_DSA_TYPE, dsa_P, FIPS_DSA_PRIME_LENGTH },
  966.     { FIPS_DSA_TYPE, dsa_Q, FIPS_DSA_SUBPRIME_LENGTH },
  967.     { FIPS_DSA_TYPE, dsa_G, FIPS_DSA_BASE_LENGTH }};
  969.     /*******************************************/
  970.     /* Generate a DSA public/private key pair. */
  971.     /*******************************************/
  973.     /* Generate a DSA public/private key pair. */
  975.     dsa_status = DSA_NewKeyFromSeed(&dsa_pqg, dsa_known_random_key_block,
  976.                                     &dsa_private_key);
  978.     if( dsa_status != SECSuccess )
  979. return( CKR_HOST_MEMORY );
  981.     /* construct public key from private key. */
  982.     dsa_public_key.params      = dsa_private_key->params;
  983.     dsa_public_key.publicValue = dsa_private_key->publicValue;
  985.     /*************************************************/
  986.     /* DSA Single-Round Known Answer Signature Test. */
  987.     /*************************************************/
  989.     dsa_signature_item.data = dsa_computed_signature;
  990.     dsa_signature_item.len  = sizeof dsa_computed_signature;
  992.     dsa_digest_item.data    = dsa_known_digest;
  993.     dsa_digest_item.len     = SHA1_LENGTH;
  995.     /* Perform DSA signature process. */
  996.     dsa_status = DSA_SignDigestWithSeed( dsa_private_key, 
  997.                                          &dsa_signature_item,
  998.  &dsa_digest_item,
  999.  dsa_known_random_signature_block );
  1001.     if( ( dsa_status != SECSuccess ) ||
  1002.         ( dsa_signature_item.len != FIPS_DSA_SIGNATURE_LENGTH ) ||
  1003.         ( PORT_Memcmp( dsa_computed_signature, dsa_known_signature,
  1004.                        FIPS_DSA_SIGNATURE_LENGTH ) != 0 ) ) {
  1005.         dsa_status = SECFailure;
  1006.     } else {
  1008.     /****************************************************/
  1009.     /* DSA Single-Round Known Answer Verification Test. */
  1010.     /****************************************************/
  1012.     /* Perform DSA verification process. */
  1013.     dsa_status = DSA_VerifyDigest( &dsa_public_key, 
  1014.                                    &dsa_signature_item,
  1015.    &dsa_digest_item);
  1016.     }
  1018.     PORT_FreeArena(dsa_private_key->params.arena, PR_TRUE);
  1019.     /* Don't free public key, it uses same arena as private key */
  1021.     /* Verify DSA signature. */
  1022.     if( dsa_status != SECSuccess )
  1023.         return( CKR_DEVICE_ERROR );
  1025.     return( CKR_OK );
  1028. }
  1031. CK_RV
  1032. pk11_fipsPowerUpSelfTest( void )
  1033. {
  1034.     CK_RV rv;
  1036.     /* RC2 Power-Up SelfTest(s). */
  1037.     rv = pk11_fips_RC2_PowerUpSelfTest();
  1039.     if( rv != CKR_OK )
  1040.         return rv;
  1042.     /* RC4 Power-Up SelfTest(s). */
  1043.     rv = pk11_fips_RC4_PowerUpSelfTest();
  1045.     if( rv != CKR_OK )
  1046.         return rv;
  1048.     /* DES Power-Up SelfTest(s). */
  1049.     rv = pk11_fips_DES_PowerUpSelfTest();
  1051.     if( rv != CKR_OK )
  1052.         return rv;
  1054.     /* DES3 Power-Up SelfTest(s). */
  1055.     rv = pk11_fips_DES3_PowerUpSelfTest();
  1057.     if( rv != CKR_OK )
  1058.         return rv;
  1060.     /* MD2 Power-Up SelfTest(s). */
  1061.     rv = pk11_fips_MD2_PowerUpSelfTest();
  1063.     if( rv != CKR_OK )
  1064.         return rv;
  1066.     /* MD5 Power-Up SelfTest(s). */
  1067.     rv = pk11_fips_MD5_PowerUpSelfTest();
  1069.     if( rv != CKR_OK )
  1070.         return rv;
  1072.     /* SHA-1 Power-Up SelfTest(s). */
  1073.     rv = pk11_fips_SHA1_PowerUpSelfTest();
  1075.     if( rv != CKR_OK )
  1076.         return rv;
  1078.     /* RSA Power-Up SelfTest(s). */
  1079.     rv = pk11_fips_RSA_PowerUpSelfTest();
  1081.     if( rv != CKR_OK )
  1082.         return rv;
  1084.     /* DSA Power-Up SelfTest(s). */
  1085.     rv = pk11_fips_DSA_PowerUpSelfTest();
  1087.     if( rv != CKR_OK )
  1088.         return rv;
  1090.     /* Passed Power-Up SelfTest(s). */
  1091.     return( CKR_OK );
  1092. }