fips/dh/fips_dhvs.c

   1 /* fips/dh/fips_dhvs.c */
   2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   3  * project.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2011 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  */
  53
  54
  55 #define OPENSSL_FIPSAPI
  56 #include <openssl/opensslconf.h>
  57
  58 #ifndef OPENSSL_FIPS
  59 #include <stdio.h>
  60
  61 int main(int argc, char **argv)
  62 {
  63     printf("No FIPS DH support\n");
  64     return(0);
  65 }
  66 #else
  67
  68 #include <openssl/crypto.h>
  69 #include <openssl/bn.h>
  70 #include <openssl/dh.h>
  71 #include <openssl/fips.h>
  72 #include <openssl/err.h>
  73 #include <openssl/evp.h>
  74 #include <string.h>
  75 #include <ctype.h>
  76
  77 #include "fips_utl.h"
  78
  79 static const EVP_MD *parse_md(char *line)
  80         {
  81         char *p;
  82         if (line[0] != '[' || line[1] != 'F')
  83                 return NULL;
  84         p = strchr(line, '-');
  85         if (!p)
  86                 return NULL;
  87         line = p + 1;
  88         p = strchr(line, ']');
  89         if (!p)
  90                 return NULL;
  91         *p = 0;
  92         p = line;
  93         while(isspace(*p))
  94                 p++;
  95         if (!strcmp(p, "SHA1"))
  96                 return EVP_sha1();
  97         else if (!strcmp(p, "SHA224"))
  98                 return EVP_sha224();
  99         else if (!strcmp(p, "SHA256"))
 100                 return EVP_sha256();
 101         else if (!strcmp(p, "SHA384"))
 102                 return EVP_sha384();
 103         else if (!strcmp(p, "SHA512"))
 104                 return EVP_sha512();
 105         else
 106                 return NULL;
 107         }
 108
 109 static void output_Zhash(FILE *out, int exout,
 110                                 DH *dh, BIGNUM *peerkey, const EVP_MD *md,
 111                                 unsigned char *rhash, size_t rhashlen)
 112         {
 113         unsigned char *Z;
 114         unsigned char chash[EVP_MAX_MD_SIZE];
 115         int Zlen;
 116         if (rhash == NULL)
 117                 {
 118                 rhashlen = M_EVP_MD_size(md);
 119                 if (!DH_generate_key(dh))
 120                         exit (1);
 121                 do_bn_print_name(out, "YephemIUT", dh->pub_key);
 122                 if (exout)
 123                         do_bn_print_name(out, "XephemIUT", dh->priv_key);
 124                 }
 125         Z = OPENSSL_malloc(BN_num_bytes(dh->p));
 126         if (!Z)
 127                 exit(1);
 128         Zlen = DH_compute_key_padded(Z, peerkey, dh);
 129         if (exout)
 130                 OutputValue("Z", Z, Zlen, out, 0);
 131         FIPS_digest(Z, Zlen, chash, NULL, md);
 132         OutputValue(rhash ? "IUTHashZZ" : "HashZZ", chash, rhashlen, out, 0);
 133         if (rhash)
 134                 {
 135                 fprintf(out, "Result = %s\n",
 136                                 memcmp(chash, rhash, rhashlen) ? "F" : "P");
 137                 }
 138         else
 139                 {
 140                 BN_clear_free(dh->priv_key);
 141                 BN_clear_free(dh->pub_key);
 142                 dh->priv_key = NULL;
 143                 dh->pub_key = NULL;
 144                 }
 145         OPENSSL_cleanse(Z, Zlen);
 146         OPENSSL_free(Z);
 147         }
 148
 149 int main(int argc,char **argv)
 150         {
 151         char **args = argv + 1;
 152         int argn = argc - 1;
 153         FILE *in, *out;
 154         char buf[2048], lbuf[2048];
 155         unsigned char *rhash;
 156         long rhashlen;
 157         DH *dh = NULL;
 158         const EVP_MD *md = NULL;
 159         BIGNUM *peerkey = NULL;
 160         char *keyword = NULL, *value = NULL;
 161         int do_verify = -1, exout = 0;
 162
 163         fips_set_error_print();
 164         if(!FIPS_mode_set(1))
 165                 exit(1);
 166
 167         if (argn && !strcmp(*args, "dhver"))
 168                 {
 169                 do_verify = 1;
 170                 args++;
 171                 argn--;
 172                 }
 173         else if (argn && !strcmp(*args, "dhgen"))
 174                 {
 175                 do_verify = 0;
 176                 args++;
 177                 argn--;
 178                 }
 179
 180         if (argn && !strcmp(*args, "-exout"))
 181                 {
 182                 exout = 1;
 183                 args++;
 184                 argn--;
 185                 }
 186
 187         if (do_verify == -1)
 188                 {
 189                 fprintf(stderr,"%s [dhver|dhgen|] [-exout] (infile outfile)\n",argv[0]);
 190                 exit(1);
 191                 }
 192
 193         if (argn == 2)
 194                 {
 195                 in = fopen(*args, "r");
 196                 if (!in)
 197                         {
 198                         fprintf(stderr, "Error opening input file\n");
 199                         exit(1);
 200                         }
 201                 out = fopen(args[1], "w");
 202                 if (!out)
 203                         {
 204                         fprintf(stderr, "Error opening output file\n");
 205                         exit(1);
 206                         }
 207                 }
 208         else if (argn == 0)
 209                 {
 210                 in = stdin;
 211                 out = stdout;
 212                 }
 213         else
 214                 {
 215                 fprintf(stderr,"%s [dhver|dhgen|] [-exout] (infile outfile)\n",argv[0]);
 216                 exit(1);
 217                 }
 218
 219         dh = FIPS_dh_new();
 220
 221         while (fgets(buf, sizeof(buf), in) != NULL)
 222                 {
 223                 fputs(buf, out);
 224                 if (strlen(buf) > 6 && !strncmp(buf, "[F", 2))
 225                         {
 226                         md = parse_md(buf);
 227                         if (md == NULL)
 228                                 goto parse_error;
 229                         if (dh)
 230                                 FIPS_dh_free(dh);
 231                         dh = FIPS_dh_new();
 232                         continue;
 233                         }
 234                 if (!parse_line(&keyword, &value, lbuf, buf))
 235                         continue;
 236                 if (!strcmp(keyword, "P"))
 237                         {
 238                         if (!do_hex2bn(&dh->p, value))
 239                                 goto parse_error;
 240                         }
 241                 else if (!strcmp(keyword, "Q"))
 242                         {
 243                         if (!do_hex2bn(&dh->q, value))
 244                                 goto parse_error;
 245                         }
 246                 else if (!strcmp(keyword, "G"))
 247                         {
 248                         if (!do_hex2bn(&dh->g, value))
 249                                 goto parse_error;
 250                         }
 251                 else if (!strcmp(keyword, "XephemIUT"))
 252                         {
 253                         if (!do_hex2bn(&dh->priv_key, value))
 254                                 goto parse_error;
 255                         }
 256                 else if (!strcmp(keyword, "YephemIUT"))
 257                         {
 258                         if (!do_hex2bn(&dh->pub_key, value))
 259                                 goto parse_error;
 260                         }
 261                 else if (!strcmp(keyword, "YephemCAVS"))
 262                         {
 263                         if (!do_hex2bn(&peerkey, value))
 264                                 goto parse_error;
 265                         if (do_verify == 0)
 266                                 output_Zhash(out, exout, dh, peerkey, md,
 267                                                         NULL, 0);
 268                         }
 269                 else if (!strcmp(keyword, "CAVSHashZZ"))
 270                         {
 271                         if (!md)
 272                                 goto parse_error;
 273                         rhash = hex2bin_m(value, &rhashlen);
 274                         if (!rhash || rhashlen != M_EVP_MD_size(md))
 275                                 goto parse_error;
 276                         output_Zhash(out, exout, dh, peerkey, md,
 277                                                         rhash, rhashlen);
 278                         }
 279                 }
 280         return 0;
 281         parse_error:
 282         fprintf(stderr, "Error Parsing request file\n");
 283         exit(1);
 284         }
 285
 286 #endif