openvpn/crypto.h

   1 /*
   2  *  OpenVPN -- An application to securely tunnel IP networks
   3  *             over a single TCP/UDP port, with support for SSL/TLS-based
   4  *             session authentication and key exchange,
   5  *             packet encryption, packet authentication, and
   6  *             packet compression.
   7  *
   8  *  Copyright (C) 2002-2005 OpenVPN Solutions LLC <info@openvpn.net>
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License version 2
  12  *  as published by the Free Software Foundation.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program (see the file COPYING included with this
  21  *  distribution); if not, write to the Free Software Foundation, Inc.,
  22  *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #ifndef CRYPTO_H
  26 #define CRYPTO_H
  27 #ifdef USE_CRYPTO
  28
  29 /*
  30  * Does our OpenSSL library support crypto hardware acceleration?
  31  */
  32 #if defined(HAVE_OPENSSL_ENGINE_H) && defined(HAVE_ENGINE_LOAD_BUILTIN_ENGINES) && defined(HAVE_ENGINE_REGISTER_ALL_COMPLETE) && defined(HAVE_ENGINE_CLEANUP)
  33 #define CRYPTO_ENGINE 1
  34 #else
  35 #define CRYPTO_ENGINE 0
  36 #endif
  37
  38 #include <openssl/objects.h>
  39 #include <openssl/rand.h>
  40 #include <openssl/evp.h>
  41 #include <openssl/hmac.h>
  42 #include <openssl/des.h>
  43 #include <openssl/md5.h>
  44 #if NTLM
  45 #include <openssl/md4.h>
  46 #endif
  47 #include <openssl/sha.h>
  48 #include <openssl/err.h>
  49
  50 #if CRYPTO_ENGINE
  51 #include <openssl/engine.h>
  52 #endif
  53
  54 #if SSLEAY_VERSION_NUMBER >= 0x00907000L
  55 #include <openssl/des_old.h>
  56 #endif
  57
  58 #include "basic.h"
  59 #include "buffer.h"
  60 #include "packet_id.h"
  61 #include "mtu.h"
  62
  63 /*
  64  * Workarounds for incompatibilites between OpenSSL libraries.
  65  * Right now we accept OpenSSL libraries from 0.9.5 to 0.9.7.
  66  */
  67
  68 #if SSLEAY_VERSION_NUMBER < 0x00907000L
  69
  70 /* Workaround: EVP_CIPHER_mode is defined wrong in OpenSSL 0.9.6 but is fixed in 0.9.7 */
  71 #undef EVP_CIPHER_mode
  72 #define EVP_CIPHER_mode(e)                (((e)->flags) & EVP_CIPH_MODE)
  73
  74 #define DES_cblock                        des_cblock
  75 #define DES_is_weak_key                   des_is_weak_key
  76 #define DES_check_key_parity              des_check_key_parity
  77 #define DES_set_odd_parity                des_set_odd_parity
  78
  79 #define HMAC_CTX_init(ctx)                CLEAR (*ctx)
  80 #define HMAC_Init_ex(ctx,sec,len,md,impl) HMAC_Init(ctx, sec, len, md)
  81 #define HMAC_CTX_cleanup(ctx)             HMAC_cleanup(ctx)
  82 #define EVP_MD_CTX_cleanup(md)            CLEAR (*md)
  83
  84 #define INFO_CALLBACK_SSL_CONST
  85
  86 #endif
  87
  88 #ifndef INFO_CALLBACK_SSL_CONST
  89 #define INFO_CALLBACK_SSL_CONST const
  90 #endif
  91
  92 #if SSLEAY_VERSION_NUMBER < 0x00906000
  93
  94 #undef EVP_CIPHER_mode
  95 #define EVP_CIPHER_mode(x) 1
  96 #define EVP_CIPHER_CTX_mode(x) 1
  97 #define EVP_CIPHER_flags(x) 0
  98
  99 #define EVP_CIPH_CBC_MODE 1
 100 #define EVP_CIPH_CFB_MODE 0
 101 #define EVP_CIPH_OFB_MODE 0
 102 #define EVP_CIPH_VARIABLE_LENGTH 0
 103
 104 #define OPENSSL_malloc(x) malloc(x)
 105 #define OPENSSL_free(x) free(x)
 106
 107 static inline int
 108 EVP_CipherInit_ov (EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, uint8_t *key, uint8_t *iv, int enc)
 109 {
 110   EVP_CipherInit (ctx, type, key, iv, enc);
 111   return 1;
 112 }
 113
 114 static inline int
 115 EVP_CipherUpdate_ov (EVP_CIPHER_CTX *ctx, uint8_t *out, int *outl, uint8_t *in, int inl)
 116 {
 117   EVP_CipherUpdate (ctx, out, outl, in, inl);
 118   return 1;
 119 }
 120
 121 static inline bool
 122 cipher_ok (const char* name)
 123 {
 124   const int i = strlen (name) - 4;
 125   if (i >= 0)
 126     return !strcmp (name + i, "-CBC");
 127   else
 128     return false;
 129 }
 130
 131 #else
 132
 133 static inline int
 134 EVP_CipherInit_ov (EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, uint8_t *key, uint8_t *iv, int enc)
 135 {
 136   return EVP_CipherInit (ctx, type, key, iv, enc);
 137 }
 138
 139 static inline int
 140 EVP_CipherUpdate_ov (EVP_CIPHER_CTX *ctx, uint8_t *out, int *outl, uint8_t *in, int inl)
 141 {
 142   return EVP_CipherUpdate (ctx, out, outl, in, inl);
 143 }
 144
 145 static inline bool
 146 cipher_ok (const char* name)
 147 {
 148   return true;
 149 }
 150
 151 #endif
 152
 153 #if SSLEAY_VERSION_NUMBER < 0x0090581f
 154 #undef DES_check_key_parity
 155 #define DES_check_key_parity(x) 1
 156 #endif
 157
 158 #ifndef EVP_CIPHER_name
 159 #define EVP_CIPHER_name(e)              OBJ_nid2sn(EVP_CIPHER_nid(e))
 160 #endif
 161
 162 #ifndef EVP_MD_name
 163 #define EVP_MD_name(e)                  OBJ_nid2sn(EVP_MD_type(e))
 164 #endif
 165
 166 /*
 167  * Max size in bytes of any cipher key that might conceivably be used.
 168  *
 169  * This value is checked at compile time in crypto.c to make sure
 170  * it is always at least EVP_MAX_KEY_LENGTH.
 171  *
 172  * We define our own value, since this parameter
 173  * is used to control the size of static key files.
 174  * If the OpenSSL library increases EVP_MAX_KEY_LENGTH,
 175  * we don't want our key files to be suddenly rendered
 176  * unusable.
 177  */
 178 #define MAX_CIPHER_KEY_LENGTH 64
 179
 180 /*
 181  * Max size in bytes of any HMAC key that might conceivably be used.
 182  *
 183  * This value is checked at compile time in crypto.c to make sure
 184  * it is always at least EVP_MAX_MD_SIZE.  We define our own value
 185  * for the same reason as above.
 186  */
 187 #define MAX_HMAC_KEY_LENGTH 64
 188
 189 /*
 190  * Defines a key type and key length for both cipher and HMAC.
 191  */
 192 struct key_type
 193 {
 194   uint8_t cipher_length;
 195   uint8_t hmac_length;
 196   const EVP_CIPHER *cipher;
 197   const EVP_MD *digest;
 198 };
 199
 200 /*
 201  * A random key.
 202  */
 203 struct key
 204 {
 205   uint8_t cipher[MAX_CIPHER_KEY_LENGTH];
 206   uint8_t hmac[MAX_HMAC_KEY_LENGTH];
 207 };
 208
 209 #define KEY_DIRECTION_BIDIRECTIONAL 0 /* same keys for both directions */
 210 #define KEY_DIRECTION_NORMAL        1 /* encrypt with keys[0], decrypt with keys[1] */
 211 #define KEY_DIRECTION_INVERSE       2 /* encrypt with keys[1], decrypt with keys[0] */
 212
 213 /*
 214  * Dual random keys (for encrypt/decrypt)
 215  */
 216 struct key2
 217 {
 218   int n;
 219   struct key keys[2];
 220 };
 221
 222 /*
 223  * Used for controlling bidirectional keys
 224  * vs. a separate key for each direction.
 225  */
 226 struct key_direction_state
 227 {
 228   int out_key;
 229   int in_key;
 230   int need_keys;
 231 };
 232
 233 /*
 234  * A key context for cipher and/or HMAC.
 235  */
 236 struct key_ctx
 237 {
 238   EVP_CIPHER_CTX *cipher;
 239   HMAC_CTX *hmac;
 240 };
 241
 242 /*
 243  * Cipher/HMAC key context for both sending and receiving
 244  * directions.
 245  */
 246 struct key_ctx_bi
 247 {
 248   struct key_ctx encrypt;
 249   struct key_ctx decrypt;
 250 };
 251
 252 /*
 253  * Options for encrypt/decrypt.
 254  */
 255 struct crypto_options
 256 {
 257   struct key_ctx_bi *key_ctx_bi;
 258   struct packet_id *packet_id;
 259   struct packet_id_persist *pid_persist;
 260
 261 # define CO_PACKET_ID_LONG_FORM  (1<<0)
 262 # define CO_USE_IV               (1<<1)
 263 # define CO_IGNORE_PACKET_ID     (1<<2)
 264 # define CO_MUTE_REPLAY_WARNINGS (1<<3)
 265   unsigned int flags;
 266 };
 267
 268 void init_key_type (struct key_type *kt, const char *ciphername,
 269                     bool ciphername_defined, const char *authname,
 270                     bool authname_defined, int keysize,
 271                     bool cfb_ofb_allowed, bool warn);
 272
 273 void read_key_file (struct key2 *key2, const char *filename, bool must_succeed);
 274
 275 int write_key_file (const int nkeys, const char *filename);
 276
 277 int read_passphrase_hash (const char *passphrase_file,
 278                           const EVP_MD *digest,
 279                           uint8_t *output,
 280                           int len);
 281
 282 void generate_key_random (struct key *key, const struct key_type *kt);
 283
 284 void check_replay_iv_consistency(const struct key_type *kt, bool packet_id, bool use_iv);
 285
 286 bool check_key (struct key *key, const struct key_type *kt);
 287
 288 void fixup_key (struct key *key, const struct key_type *kt);
 289
 290 bool write_key (const struct key *key, const struct key_type *kt,
 291                 struct buffer *buf);
 292
 293 int read_key (struct key *key, const struct key_type *kt, struct buffer *buf);
 294
 295 bool cfb_ofb_mode (const struct key_type* kt);
 296
 297 const char *kt_cipher_name (const struct key_type *kt);
 298 const char *kt_digest_name (const struct key_type *kt);
 299 int kt_key_size (const struct key_type *kt);
 300
 301 /* enc parameter in init_key_ctx */
 302 #define DO_ENCRYPT 1
 303 #define DO_DECRYPT 0
 304
 305 void init_key_ctx (struct key_ctx *ctx, struct key *key,
 306                    const struct key_type *kt, int enc,
 307                    const char *prefix);
 308
 309 void free_key_ctx (struct key_ctx *ctx);
 310 void free_key_ctx_bi (struct key_ctx_bi *ctx);
 311
 312 void openvpn_encrypt (struct buffer *buf, struct buffer work,
 313                       const struct crypto_options *opt,
 314                       const struct frame* frame);
 315
 316 bool openvpn_decrypt (struct buffer *buf, struct buffer work,
 317                       const struct crypto_options *opt,
 318                       const struct frame* frame);
 319
 320
 321 void crypto_adjust_frame_parameters(struct frame *frame,
 322                                     const struct key_type* kt,
 323                                     bool cipher_defined,
 324                                     bool use_iv,
 325                                     bool packet_id,
 326                                     bool packet_id_long_form);
 327
 328 void prng_init (void);
 329 void prng_bytes (uint8_t *output, int len);
 330
 331 void test_crypto (const struct crypto_options *co, struct frame* f);
 332
 333 const char *md5sum(uint8_t *buf, int len, int n_print_chars, struct gc_arena *gc);
 334
 335 void show_available_ciphers (void);
 336
 337 void show_available_digests (void);
 338
 339 void show_available_engines (void);
 340
 341 void init_crypto_lib_engine (const char *engine_name);
 342
 343 void init_crypto_lib (void);
 344
 345 void uninit_crypto_lib (void);
 346
 347 /* key direction functions */
 348
 349 void key_direction_state_init (struct key_direction_state *kds, int key_direction);
 350
 351 void verify_fix_key2 (struct key2 *key2, const struct key_type *kt, const char *shared_secret_file);
 352
 353 void must_have_n_keys (const char *filename, const char *option, const struct key2 *key2, int n);
 354
 355 int ascii2keydirection (int msglevel, const char *str);
 356
 357 const char *keydirection2ascii (int kd, bool remote);
 358
 359 /* print keys */
 360 void key2_print (const struct key2* k,
 361                  const struct key_type *kt,
 362                  const char* prefix0,
 363                  const char* prefix1);
 364
 365 /* memory debugging */
 366 void openssl_dmalloc_init (void);
 367
 368 #ifdef USE_SSL
 369
 370 void get_tls_handshake_key (const struct key_type *key_type,
 371                             struct key_ctx_bi *ctx,
 372                             const char *passphrase_file,
 373                             bool key_direction);
 374
 375 #else
 376
 377 void init_ssl_lib (void);
 378 void free_ssl_lib (void);
 379
 380 #endif /* USE_SSL */
 381
 382 /*
 383  * Inline functions
 384  */
 385
 386 static inline bool
 387 key_ctx_bi_defined(const struct key_ctx_bi* key)
 388 {
 389   return key->encrypt.cipher || key->encrypt.hmac || key->decrypt.cipher || key->decrypt.hmac;
 390 }
 391
 392 #endif /* USE_CRYPTO */
 393 #endif /* CRYPTO_H */