src/plugins/ikev2/ikev2_crypto.c

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vlib/vlib.h>
  17 #include <vnet/vnet.h>
  18 #include <vnet/pg/pg.h>
  19 #include <vppinfra/error.h>
  20 #include <vnet/udp/udp.h>
  21 #include <plugins/ikev2/ikev2.h>
  22 #include <plugins/ikev2/ikev2_priv.h>
  23 #include <openssl/obj_mac.h>
  24 #include <openssl/ec.h>
  25 #include <openssl/x509.h>
  26 #include <openssl/pem.h>
  27 #include <openssl/bn.h>
  28 #include <openssl/dh.h>
  29
  30 /* from RFC7296 */
  31 static const char modp_dh_768_prime[] =
  32   "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
  33   "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
  34   "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
  35   "E485B576625E7EC6F44C42E9A63A3620FFFFFFFFFFFFFFFF";
  36 static const char modp_dh_768_generator[] = "02";
  37
  38 static const char modp_dh_1024_prime[] =
  39   "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
  40   "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
  41   "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
  42   "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
  43   "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381" "FFFFFFFFFFFFFFFF";
  44 static const char modp_dh_1024_generator[] = "02";
  45
  46 /* from RFC3526 */
  47 static const char modp_dh_1536_prime[] =
  48   "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
  49   "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
  50   "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
  51   "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
  52   "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
  53   "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
  54   "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
  55   "670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF";
  56 static const char modp_dh_1536_generator[] = "02";
  57
  58 static const char modp_dh_2048_prime[] =
  59   "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
  60   "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
  61   "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
  62   "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
  63   "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
  64   "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
  65   "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
  66   "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
  67   "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
  68   "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
  69   "15728E5A8AACAA68FFFFFFFFFFFFFFFF";
  70 static const char modp_dh_2048_generator[] = "02";
  71
  72 static const char modp_dh_3072_prime[] =
  73   "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
  74   "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
  75   "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
  76   "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
  77   "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
  78   "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
  79   "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
  80   "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
  81   "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
  82   "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
  83   "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
  84   "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
  85   "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
  86   "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
  87   "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
  88   "43DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF";
  89 static const char modp_dh_3072_generator[] = "02";
  90
  91 static const char modp_dh_4096_prime[] =
  92   "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
  93   "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
  94   "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
  95   "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
  96   "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
  97   "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
  98   "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
  99   "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
 100   "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
 101   "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
 102   "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
 103   "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
 104   "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
 105   "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
 106   "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
 107   "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
 108   "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
 109   "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
 110   "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
 111   "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
 112   "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199" "FFFFFFFFFFFFFFFF";
 113 static const char modp_dh_4096_generator[] = "02";
 114
 115 static const char modp_dh_6144_prime[] =
 116   "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E08"
 117   "8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B"
 118   "302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9"
 119   "A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE6"
 120   "49286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8"
 121   "FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D"
 122   "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C"
 123   "180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"
 124   "3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D"
 125   "04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7D"
 126   "B3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D226"
 127   "1AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
 128   "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFC"
 129   "E0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B26"
 130   "99C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB"
 131   "04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2"
 132   "233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127"
 133   "D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
 134   "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406"
 135   "AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918"
 136   "DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B33205151"
 137   "2BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03"
 138   "F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97F"
 139   "BEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
 140   "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58B"
 141   "B7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632"
 142   "387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E"
 143   "6DCC4024FFFFFFFFFFFFFFFF";
 144 static const char modp_dh_6144_generator[] = "02";
 145
 146 static const char modp_dh_8192_prime[] =
 147   "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
 148   "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
 149   "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
 150   "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
 151   "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
 152   "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
 153   "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
 154   "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
 155   "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
 156   "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
 157   "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
 158   "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
 159   "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
 160   "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
 161   "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
 162   "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
 163   "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
 164   "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
 165   "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
 166   "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
 167   "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
 168   "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BD"
 169   "F8FF9406AD9E530EE5DB382F413001AEB06A53ED9027D831"
 170   "179727B0865A8918DA3EDBEBCF9B14ED44CE6CBACED4BB1B"
 171   "DB7F1447E6CC254B332051512BD7AF426FB8F401378CD2BF"
 172   "5983CA01C64B92ECF032EA15D1721D03F482D7CE6E74FEF6"
 173   "D55E702F46980C82B5A84031900B1C9E59E7C97FBEC7E8F3"
 174   "23A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
 175   "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE328"
 176   "06A1D58BB7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55C"
 177   "DA56C9EC2EF29632387FE8D76E3C0468043E8F663F4860EE"
 178   "12BF2D5B0B7474D6E694F91E6DBE115974A3926F12FEE5E4"
 179   "38777CB6A932DF8CD8BEC4D073B931BA3BC832B68D9DD300"
 180   "741FA7BF8AFC47ED2576F6936BA424663AAB639C5AE4F568"
 181   "3423B4742BF1C978238F16CBE39D652DE3FDB8BEFC848AD9"
 182   "22222E04A4037C0713EB57A81A23F0C73473FC646CEA306B"
 183   "4BCBC8862F8385DDFA9D4B7FA2C087E879683303ED5BDD3A"
 184   "062B3CF5B3A278A66D2A13F83F44F82DDF310EE074AB6A36"
 185   "4597E899A0255DC164F31CC50846851DF9AB48195DED7EA1"
 186   "B1D510BD7EE74D73FAF36BC31ECFA268359046F4EB879F92"
 187   "4009438B481C6CD7889A002ED5EE382BC9190DA6FC026E47"
 188   "9558E4475677E9AA9E3050E2765694DFC81F56E880B96E71"
 189   "60C980DD98EDD3DFFFFFFFFFFFFFFFFF";
 190 static const char modp_dh_8192_generator[] = "02";
 191
 192 /* from RFC5114 */
 193 static const char modp_dh_1024_160_prime[] =
 194   "B10B8F96A080E01DDE92DE5EAE5D54EC52C99FBCFB06A3C6"
 195   "9A6A9DCA52D23B616073E28675A23D189838EF1E2EE652C0"
 196   "13ECB4AEA906112324975C3CD49B83BFACCBDD7D90C4BD70"
 197   "98488E9C219A73724EFFD6FAE5644738FAA31A4FF55BCCC0"
 198   "A151AF5F0DC8B4BD45BF37DF365C1A65E68CFDA76D4DA708" "DF1FB2BC2E4A4371";
 199 static const char modp_dh_1024_160_generator[] =
 200   "A4D1CBD5C3FD34126765A442EFB99905F8104DD258AC507F"
 201   "D6406CFF14266D31266FEA1E5C41564B777E690F5504F213"
 202   "160217B4B01B886A5E91547F9E2749F4D7FBD7D3B9A92EE1"
 203   "909D0D2263F80A76A6A24C087A091F531DBF0A0169B6A28A"
 204   "D662A4D18E73AFA32D779D5918D08BC8858F4DCEF97C2A24" "855E6EEB22B3B2E5";
 205
 206 static const char modp_dh_2048_224_prime[] =
 207   "AD107E1E9123A9D0D660FAA79559C51FA20D64E5683B9FD1"
 208   "B54B1597B61D0A75E6FA141DF95A56DBAF9A3C407BA1DF15"
 209   "EB3D688A309C180E1DE6B85A1274A0A66D3F8152AD6AC212"
 210   "9037C9EDEFDA4DF8D91E8FEF55B7394B7AD5B7D0B6C12207"
 211   "C9F98D11ED34DBF6C6BA0B2C8BBC27BE6A00E0A0B9C49708"
 212   "B3BF8A317091883681286130BC8985DB1602E714415D9330"
 213   "278273C7DE31EFDC7310F7121FD5A07415987D9ADC0A486D"
 214   "CDF93ACC44328387315D75E198C641A480CD86A1B9E587E8"
 215   "BE60E69CC928B2B9C52172E413042E9B23F10B0E16E79763"
 216   "C9B53DCF4BA80A29E3FB73C16B8E75B97EF363E2FFA31F71"
 217   "CF9DE5384E71B81C0AC4DFFE0C10E64F";
 218 static const char modp_dh_2048_224_generator[] =
 219   "AC4032EF4F2D9AE39DF30B5C8FFDAC506CDEBE7B89998CAF"
 220   "74866A08CFE4FFE3A6824A4E10B9A6F0DD921F01A70C4AFA"
 221   "AB739D7700C29F52C57DB17C620A8652BE5E9001A8D66AD7"
 222   "C17669101999024AF4D027275AC1348BB8A762D0521BC98A"
 223   "E247150422EA1ED409939D54DA7460CDB5F6C6B250717CBE"
 224   "F180EB34118E98D119529A45D6F834566E3025E316A330EF"
 225   "BB77A86F0C1AB15B051AE3D428C8F8ACB70A8137150B8EEB"
 226   "10E183EDD19963DDD9E263E4770589EF6AA21E7F5F2FF381"
 227   "B539CCE3409D13CD566AFBB48D6C019181E1BCFE94B30269"
 228   "EDFE72FE9B6AA4BD7B5A0F1C71CFFF4C19C418E1F6EC0179"
 229   "81BC087F2A7065B384B890D3191F2BFA";
 230
 231 static const char modp_dh_2048_256_prime[] =
 232   "87A8E61DB4B6663CFFBBD19C651959998CEEF608660DD0F2"
 233   "5D2CEED4435E3B00E00DF8F1D61957D4FAF7DF4561B2AA30"
 234   "16C3D91134096FAA3BF4296D830E9A7C209E0C6497517ABD"
 235   "5A8A9D306BCF67ED91F9E6725B4758C022E0B1EF4275BF7B"
 236   "6C5BFC11D45F9088B941F54EB1E59BB8BC39A0BF12307F5C"
 237   "4FDB70C581B23F76B63ACAE1CAA6B7902D52526735488A0E"
 238   "F13C6D9A51BFA4AB3AD8347796524D8EF6A167B5A41825D9"
 239   "67E144E5140564251CCACB83E6B486F6B3CA3F7971506026"
 240   "C0B857F689962856DED4010ABD0BE621C3A3960A54E710C3"
 241   "75F26375D7014103A4B54330C198AF126116D2276E11715F"
 242   "693877FAD7EF09CADB094AE91E1A1597";
 243 static const char modp_dh_2048_256_generator[] =
 244   "3FB32C9B73134D0B2E77506660EDBD484CA7B18F21EF2054"
 245   "07F4793A1A0BA12510DBC15077BE463FFF4FED4AAC0BB555"
 246   "BE3A6C1B0C6B47B1BC3773BF7E8C6F62901228F8C28CBB18"
 247   "A55AE31341000A650196F931C77A57F2DDF463E5E9EC144B"
 248   "777DE62AAAB8A8628AC376D282D6ED3864E67982428EBC83"
 249   "1D14348F6F2F9193B5045AF2767164E1DFC967C1FB3F2E55"
 250   "A4BD1BFFE83B9C80D052B985D182EA0ADB2A3B7313D3FE14"
 251   "C8484B1E052588B9B7D2BBD2DF016199ECD06E1557CD0915"
 252   "B3353BBB64E0EC377FD028370DF92B52C7891428CDC67EB6"
 253   "184B523D1DB246C32F63078490F00EF8D647D148D4795451"
 254   "5E2327CFEF98C582664B4C0F6CC41659";
 255
 256 v8 *
 257 ikev2_calc_prf (ikev2_sa_transform_t * tr, v8 * key, v8 * data)
 258 {
 259   ikev2_main_t *km = &ikev2_main;
 260   u32 thread_index = vlib_get_thread_index ();
 261   ikev2_main_per_thread_data_t *ptd =
 262     vec_elt_at_index (km->per_thread_data, thread_index);
 263   HMAC_CTX *ctx = ptd->hmac_ctx;
 264   v8 *prf;
 265   unsigned int len = 0;
 266
 267   prf = vec_new (u8, tr->key_trunc);
 268   HMAC_Init_ex (ctx, key, vec_len (key), tr->md, NULL);
 269   HMAC_Update (ctx, data, vec_len (data));
 270   HMAC_Final (ctx, prf, &len);
 271   ASSERT (len == tr->key_trunc);
 272
 273   return prf;
 274 }
 275
 276 u8 *
 277 ikev2_calc_prfplus (ikev2_sa_transform_t * tr, u8 * key, u8 * seed, int len)
 278 {
 279   v8 *t = 0, *s = 0, *tmp = 0, *ret = 0;
 280   u8 x = 0;
 281
 282   /* prf+ (K,S) = T1 | T2 | T3 | T4 | ...
 283
 284      where:
 285      T1 = prf (K, S | 0x01)
 286      T2 = prf (K, T1 | S | 0x02)
 287      T3 = prf (K, T2 | S | 0x03)
 288      T4 = prf (K, T3 | S | 0x04)
 289    */
 290
 291   while (vec_len (ret) < len && x < 255)
 292     {
 293       if (t)
 294         {
 295           vec_append (s, t);
 296           vec_free (t);
 297         }
 298
 299       vec_append (s, seed);
 300       vec_add2 (s, tmp, 1);
 301       *tmp = x + 1;
 302       t = ikev2_calc_prf (tr, key, s);
 303       vec_append (ret, t);
 304       vec_free (s);
 305       x++;
 306     }
 307
 308   vec_free (t);
 309
 310   if (x == 255)
 311     {
 312       vec_free (ret);
 313     }
 314
 315   return ret;
 316 }
 317
 318 v8 *
 319 ikev2_calc_integr (ikev2_sa_transform_t * tr, v8 * key, u8 * data, int len)
 320 {
 321   ikev2_main_t *km = &ikev2_main;
 322   u32 thread_index = vlib_get_thread_index ();
 323   ikev2_main_per_thread_data_t *ptd =
 324     vec_elt_at_index (km->per_thread_data, thread_index);
 325   HMAC_CTX *ctx = ptd->hmac_ctx;
 326   v8 *r;
 327   unsigned int l;
 328
 329   ASSERT (tr->type == IKEV2_TRANSFORM_TYPE_INTEG);
 330
 331   r = vec_new (u8, tr->key_len);
 332
 333   if (tr->md == EVP_sha1 ())
 334     {
 335       ikev2_elog_debug ("integrity checking with sha1");
 336     }
 337   else if (tr->md == EVP_sha256 ())
 338     {
 339       ikev2_elog_debug ("integrity checking with sha256");
 340     }
 341
 342   /* verify integrity of data */
 343   HMAC_Init_ex (ctx, key, vec_len (key), tr->md, NULL);
 344   HMAC_Update (ctx, (const u8 *) data, len);
 345   HMAC_Final (ctx, r, &l);
 346   ASSERT (l == tr->key_len);
 347
 348   return r;
 349 }
 350
 351 v8 *
 352 ikev2_decrypt_data (ikev2_sa_t * sa, u8 * data, int len)
 353 {
 354   ikev2_main_t *km = &ikev2_main;
 355   u32 thread_index = vlib_get_thread_index ();
 356   ikev2_main_per_thread_data_t *ptd =
 357     vec_elt_at_index (km->per_thread_data, thread_index);
 358   EVP_CIPHER_CTX *ctx = ptd->evp_ctx;
 359   int out_len = 0, block_size;
 360   ikev2_sa_transform_t *tr_encr;
 361   u8 *key = sa->is_initiator ? sa->sk_er : sa->sk_ei;
 362
 363   tr_encr =
 364     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
 365   block_size = tr_encr->block_size;
 366
 367   /* check if data is multiplier of cipher block size */
 368   if (len % block_size)
 369     {
 370       ikev2_elog_error ("wrong data length");
 371       return 0;
 372     }
 373
 374   v8 *r = vec_new (u8, len - block_size);
 375   EVP_DecryptInit_ex (ctx, tr_encr->cipher, NULL, key, data);
 376   EVP_DecryptUpdate (ctx, r, &out_len, data + block_size, len - block_size);
 377   EVP_DecryptFinal_ex (ctx, r + out_len, &out_len);
 378   /* remove padding */
 379   _vec_len (r) -= r[vec_len (r) - 1] + 1;
 380
 381   return r;
 382 }
 383
 384 int
 385 ikev2_encrypt_data (ikev2_sa_t * sa, v8 * src, u8 * dst)
 386 {
 387   ikev2_main_t *km = &ikev2_main;
 388   u32 thread_index = vlib_get_thread_index ();
 389   ikev2_main_per_thread_data_t *ptd =
 390     vec_elt_at_index (km->per_thread_data, thread_index);
 391   EVP_CIPHER_CTX *ctx = ptd->evp_ctx;
 392   int out_len;
 393   int bs;
 394   ikev2_sa_transform_t *tr_encr;
 395   u8 *key = sa->is_initiator ? sa->sk_ei : sa->sk_er;
 396
 397   tr_encr =
 398     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
 399   bs = tr_encr->block_size;
 400
 401   /* generate IV */
 402   RAND_bytes (dst, bs);
 403
 404   EVP_EncryptInit_ex (ctx, tr_encr->cipher, NULL, key, dst /* dst */ );
 405   EVP_EncryptUpdate (ctx, dst + bs, &out_len, src, vec_len (src));
 406
 407   ASSERT (vec_len (src) == out_len);
 408
 409   return out_len + bs;
 410 }
 411
 412 #ifndef BN_bn2binpad
 413 int
 414 BN_bn2binpad (const BIGNUM * a, unsigned char *to, int tolen)
 415 {
 416   int r = BN_bn2bin (a, to);
 417   ASSERT (tolen >= r);
 418   int pad = tolen - r;
 419   if (pad)
 420     {
 421       vec_insert (to, pad, 0);
 422       clib_memset (to, 0, pad);
 423       _vec_len (to) -= pad;
 424     }
 425   return tolen;
 426 }
 427 #endif
 428
 429 void
 430 ikev2_generate_dh (ikev2_sa_t * sa, ikev2_sa_transform_t * t)
 431 {
 432   int r;
 433
 434   if (t->dh_group == IKEV2_DH_GROUP_MODP)
 435     {
 436       DH *dh = DH_new ();
 437 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
 438       BIGNUM *p = NULL;
 439       BIGNUM *g = NULL;
 440       const BIGNUM *pub_key, *priv_key;
 441
 442       BN_hex2bn (&p, t->dh_p);
 443       BN_hex2bn (&g, t->dh_g);
 444       DH_set0_pqg (dh, p, NULL, g);
 445 #else
 446       BN_hex2bn (&dh->p, t->dh_p);
 447       BN_hex2bn (&dh->g, t->dh_g);
 448 #endif
 449       DH_generate_key (dh);
 450
 451       if (sa->is_initiator)
 452         {
 453           sa->i_dh_data = vec_new (u8, t->key_len);
 454           sa->dh_private_key = vec_new (u8, t->key_len);
 455 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
 456           DH_get0_key (dh, &pub_key, &priv_key);
 457           r = BN_bn2binpad (pub_key, sa->i_dh_data, t->key_len);
 458           ASSERT (r == t->key_len);
 459           r = BN_bn2binpad (priv_key, sa->dh_private_key, t->key_len);
 460 #else
 461           r = BN_bn2binpad (dh->pub_key, sa->i_dh_data, t->key_len);
 462           ASSERT (r == t->key_len);
 463           r = BN_bn2binpad (dh->priv_key, sa->dh_private_key, t->key_len);
 464 #endif
 465           ASSERT (r == t->key_len);
 466         }
 467       else
 468         {
 469           sa->r_dh_data = vec_new (u8, t->key_len);
 470 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
 471           DH_get0_key (dh, &pub_key, &priv_key);
 472           r = BN_bn2binpad (pub_key, sa->r_dh_data, t->key_len);
 473 #else
 474           r = BN_bn2binpad (dh->pub_key, sa->r_dh_data, t->key_len);
 475 #endif
 476           ASSERT (r == t->key_len);
 477
 478           BIGNUM *ex;
 479           sa->dh_shared_key = vec_new (u8, t->key_len);
 480           ex = BN_bin2bn (sa->i_dh_data, vec_len (sa->i_dh_data), NULL);
 481           r = DH_compute_key (sa->dh_shared_key, ex, dh);
 482           ASSERT (t->key_len >= r);
 483           int pad = t->key_len - r;
 484           if (pad)
 485             {
 486               vec_insert (sa->dh_shared_key, pad, 0);
 487               clib_memset (sa->dh_shared_key, 0, pad);
 488               _vec_len (sa->dh_shared_key) -= pad;
 489             }
 490           BN_clear_free (ex);
 491         }
 492       DH_free (dh);
 493     }
 494   else if (t->dh_group == IKEV2_DH_GROUP_ECP)
 495     {
 496       EC_KEY *ec = EC_KEY_new_by_curve_name (t->nid);
 497       ASSERT (ec);
 498
 499       EC_KEY_generate_key (ec);
 500
 501       const EC_POINT *r_point = EC_KEY_get0_public_key (ec);
 502       const EC_GROUP *group = EC_KEY_get0_group (ec);
 503       BIGNUM *x = NULL, *y = NULL;
 504       BN_CTX *bn_ctx = BN_CTX_new ();
 505       u16 x_off, y_off, len;
 506       EC_POINT *i_point = EC_POINT_new (group);
 507       EC_POINT *shared_point = EC_POINT_new (group);
 508
 509       x = BN_new ();
 510       y = BN_new ();
 511       len = t->key_len / 2;
 512
 513 #if OPENSSL_VERSION_NUMBER >= 0x30000000L
 514       EC_POINT_get_affine_coordinates (group, r_point, x, y, bn_ctx);
 515 #else
 516       EC_POINT_get_affine_coordinates_GFp (group, r_point, x, y, bn_ctx);
 517 #endif
 518
 519       if (sa->is_initiator)
 520         {
 521           sa->i_dh_data = vec_new (u8, t->key_len);
 522           x_off = len - BN_num_bytes (x);
 523           clib_memset (sa->i_dh_data, 0, x_off);
 524           BN_bn2bin (x, sa->i_dh_data + x_off);
 525           y_off = t->key_len - BN_num_bytes (y);
 526           clib_memset (sa->i_dh_data + len, 0, y_off - len);
 527           BN_bn2bin (y, sa->i_dh_data + y_off);
 528
 529           const BIGNUM *prv = EC_KEY_get0_private_key (ec);
 530           sa->dh_private_key = vec_new (u8, BN_num_bytes (prv));
 531           r = BN_bn2bin (prv, sa->dh_private_key);
 532           ASSERT (r == BN_num_bytes (prv));
 533         }
 534       else
 535         {
 536           sa->r_dh_data = vec_new (u8, t->key_len);
 537           x_off = len - BN_num_bytes (x);
 538           clib_memset (sa->r_dh_data, 0, x_off);
 539           BN_bn2bin (x, sa->r_dh_data + x_off);
 540           y_off = t->key_len - BN_num_bytes (y);
 541           clib_memset (sa->r_dh_data + len, 0, y_off - len);
 542           BN_bn2bin (y, sa->r_dh_data + y_off);
 543
 544           x = BN_bin2bn (sa->i_dh_data, len, x);
 545           y = BN_bin2bn (sa->i_dh_data + len, len, y);
 546 #if OPENSSL_VERSION_NUMBER >= 0x30000000L
 547           EC_POINT_set_affine_coordinates (group, i_point, x, y, bn_ctx);
 548 #else
 549           EC_POINT_set_affine_coordinates_GFp (group, i_point, x, y, bn_ctx);
 550 #endif
 551           sa->dh_shared_key = vec_new (u8, t->key_len);
 552           EC_POINT_mul (group, shared_point, NULL, i_point,
 553                         EC_KEY_get0_private_key (ec), NULL);
 554 #if OPENSSL_VERSION_NUMBER >= 0x30000000L
 555           EC_POINT_get_affine_coordinates (group, shared_point, x, y, bn_ctx);
 556 #else
 557           EC_POINT_get_affine_coordinates_GFp (group, shared_point, x, y,
 558                                                bn_ctx);
 559 #endif
 560           x_off = len - BN_num_bytes (x);
 561           clib_memset (sa->dh_shared_key, 0, x_off);
 562           BN_bn2bin (x, sa->dh_shared_key + x_off);
 563           y_off = t->key_len - BN_num_bytes (y);
 564           clib_memset (sa->dh_shared_key + len, 0, y_off - len);
 565           BN_bn2bin (y, sa->dh_shared_key + y_off);
 566         }
 567
 568       EC_KEY_free (ec);
 569       BN_free (x);
 570       BN_free (y);
 571       BN_CTX_free (bn_ctx);
 572       EC_POINT_free (i_point);
 573       EC_POINT_free (shared_point);
 574     }
 575 }
 576
 577 void
 578 ikev2_complete_dh (ikev2_sa_t * sa, ikev2_sa_transform_t * t)
 579 {
 580   int r;
 581
 582   if (t->dh_group == IKEV2_DH_GROUP_MODP)
 583     {
 584       DH *dh = DH_new ();
 585 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
 586       BIGNUM *p = NULL;
 587       BIGNUM *g = NULL;
 588       BIGNUM *priv_key;
 589
 590       BN_hex2bn (&p, t->dh_p);
 591       BN_hex2bn (&g, t->dh_g);
 592       DH_set0_pqg (dh, p, NULL, g);
 593
 594       priv_key =
 595         BN_bin2bn (sa->dh_private_key, vec_len (sa->dh_private_key), NULL);
 596       DH_set0_key (dh, NULL, priv_key);
 597 #else
 598       BN_hex2bn (&dh->p, t->dh_p);
 599       BN_hex2bn (&dh->g, t->dh_g);
 600
 601       dh->priv_key =
 602         BN_bin2bn (sa->dh_private_key, vec_len (sa->dh_private_key), NULL);
 603 #endif
 604       BIGNUM *ex;
 605       sa->dh_shared_key = vec_new (u8, t->key_len);
 606       ex = BN_bin2bn (sa->r_dh_data, vec_len (sa->r_dh_data), NULL);
 607       r = DH_compute_key (sa->dh_shared_key, ex, dh);
 608       ASSERT (t->key_len >= r);
 609       int pad = t->key_len - r;
 610       if (pad)
 611         {
 612           vec_insert (sa->dh_shared_key, pad, 0);
 613           clib_memset (sa->dh_shared_key, 0, pad);
 614           _vec_len (sa->dh_shared_key) -= pad;
 615         }
 616       BN_clear_free (ex);
 617       DH_free (dh);
 618     }
 619   else if (t->dh_group == IKEV2_DH_GROUP_ECP)
 620     {
 621       EC_KEY *ec = EC_KEY_new_by_curve_name (t->nid);
 622       ASSERT (ec);
 623
 624       const EC_GROUP *group = EC_KEY_get0_group (ec);
 625       BIGNUM *x = NULL, *y = NULL;
 626       BN_CTX *bn_ctx = BN_CTX_new ();
 627       u16 x_off, y_off, len;
 628       BIGNUM *prv;
 629
 630       prv =
 631         BN_bin2bn (sa->dh_private_key, vec_len (sa->dh_private_key), NULL);
 632       EC_KEY_set_private_key (ec, prv);
 633
 634       x = BN_new ();
 635       y = BN_new ();
 636       len = t->key_len / 2;
 637
 638       x = BN_bin2bn (sa->r_dh_data, len, x);
 639       y = BN_bin2bn (sa->r_dh_data + len, len, y);
 640       EC_POINT *r_point = EC_POINT_new (group);
 641 #if OPENSSL_VERSION_NUMBER >= 0x30000000L
 642       EC_POINT_set_affine_coordinates (group, r_point, x, y, bn_ctx);
 643 #else
 644       EC_POINT_set_affine_coordinates_GFp (group, r_point, x, y, bn_ctx);
 645 #endif
 646       EC_KEY_set_public_key (ec, r_point);
 647
 648       EC_POINT *i_point = EC_POINT_new (group);
 649       EC_POINT *shared_point = EC_POINT_new (group);
 650
 651       x = BN_bin2bn (sa->i_dh_data, len, x);
 652       y = BN_bin2bn (sa->i_dh_data + len, len, y);
 653 #if OPENSSL_VERSION_NUMBER >= 0x30000000L
 654       EC_POINT_set_affine_coordinates (group, i_point, x, y, bn_ctx);
 655 #else
 656       EC_POINT_set_affine_coordinates_GFp (group, i_point, x, y, bn_ctx);
 657 #endif
 658       EC_POINT_mul (group, shared_point, NULL, r_point,
 659                     EC_KEY_get0_private_key (ec), NULL);
 660 #if OPENSSL_VERSION_NUMBER >= 0x30000000L
 661       EC_POINT_get_affine_coordinates (group, shared_point, x, y, bn_ctx);
 662 #else
 663       EC_POINT_get_affine_coordinates_GFp (group, shared_point, x, y, bn_ctx);
 664 #endif
 665       sa->dh_shared_key = vec_new (u8, t->key_len);
 666       x_off = len - BN_num_bytes (x);
 667       clib_memset (sa->dh_shared_key, 0, x_off);
 668       BN_bn2bin (x, sa->dh_shared_key + x_off);
 669       y_off = t->key_len - BN_num_bytes (y);
 670       clib_memset (sa->dh_shared_key + len, 0, y_off - len);
 671       BN_bn2bin (y, sa->dh_shared_key + y_off);
 672
 673       EC_KEY_free (ec);
 674       BN_free (x);
 675       BN_free (y);
 676       BN_free (prv);
 677       BN_CTX_free (bn_ctx);
 678       EC_POINT_free (i_point);
 679       EC_POINT_free (r_point);
 680       EC_POINT_free (shared_point);
 681     }
 682 }
 683
 684 int
 685 ikev2_verify_sign (EVP_PKEY * pkey, u8 * sigbuf, u8 * data)
 686 {
 687   int verify;
 688 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
 689   EVP_MD_CTX *md_ctx = EVP_MD_CTX_new ();
 690 #else
 691   EVP_MD_CTX md_ctx;
 692   EVP_MD_CTX_init (&md_ctx);
 693 #endif
 694
 695 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
 696   EVP_VerifyInit (md_ctx, EVP_sha1 ());
 697   EVP_VerifyUpdate (md_ctx, data, vec_len (data));
 698 #else
 699   EVP_VerifyInit_ex (&md_ctx, EVP_sha1 (), NULL);
 700   EVP_VerifyUpdate (&md_ctx, data, vec_len (data));
 701 #endif
 702
 703 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
 704   verify = EVP_VerifyFinal (md_ctx, sigbuf, vec_len (sigbuf), pkey);
 705   EVP_MD_CTX_free (md_ctx);
 706 #else
 707   verify = EVP_VerifyFinal (&md_ctx, sigbuf, vec_len (sigbuf), pkey);
 708   EVP_MD_CTX_cleanup (&md_ctx);
 709 #endif
 710   return verify;
 711 }
 712
 713 u8 *
 714 ikev2_calc_sign (EVP_PKEY * pkey, u8 * data)
 715 {
 716 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
 717   EVP_MD_CTX *md_ctx = EVP_MD_CTX_new ();
 718 #else
 719   EVP_MD_CTX md_ctx;
 720   EVP_MD_CTX_init (&md_ctx);
 721 #endif
 722   unsigned int sig_len = 0;
 723   u8 *sign;
 724
 725 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
 726   EVP_SignInit (md_ctx, EVP_sha1 ());
 727   EVP_SignUpdate (md_ctx, data, vec_len (data));
 728   /* get sign len */
 729   EVP_SignFinal (md_ctx, NULL, &sig_len, pkey);
 730   sign = vec_new (u8, sig_len);
 731   /* calc sign */
 732   EVP_SignFinal (md_ctx, sign, &sig_len, pkey);
 733   EVP_MD_CTX_free (md_ctx);
 734 #else
 735   EVP_SignInit (&md_ctx, EVP_sha1 ());
 736   EVP_SignUpdate (&md_ctx, data, vec_len (data));
 737   /* get sign len */
 738   EVP_SignFinal (&md_ctx, NULL, &sig_len, pkey);
 739   sign = vec_new (u8, sig_len);
 740   /* calc sign */
 741   EVP_SignFinal (&md_ctx, sign, &sig_len, pkey);
 742   EVP_MD_CTX_cleanup (&md_ctx);
 743 #endif
 744   return sign;
 745 }
 746
 747 EVP_PKEY *
 748 ikev2_load_cert_file (u8 * file)
 749 {
 750   FILE *fp;
 751   X509 *x509;
 752   EVP_PKEY *pkey = NULL;
 753
 754   fp = fopen ((char *) file, "r");
 755   if (!fp)
 756     {
 757       ikev2_log_error ("open %s failed", file);
 758       goto end;
 759     }
 760
 761   x509 = PEM_read_X509 (fp, NULL, NULL, NULL);
 762   fclose (fp);
 763   if (x509 == NULL)
 764     {
 765       ikev2_log_error ("read cert %s failed", file);
 766       goto end;
 767     }
 768
 769   pkey = X509_get_pubkey (x509);
 770   if (pkey == NULL)
 771     ikev2_log_error ("get pubkey %s failed", file);
 772
 773 end:
 774   return pkey;
 775 }
 776
 777 EVP_PKEY *
 778 ikev2_load_key_file (u8 * file)
 779 {
 780   FILE *fp;
 781   EVP_PKEY *pkey = NULL;
 782
 783   fp = fopen ((char *) file, "r");
 784   if (!fp)
 785     {
 786       ikev2_log_error ("open %s failed", file);
 787       goto end;
 788     }
 789
 790   pkey = PEM_read_PrivateKey (fp, NULL, NULL, NULL);
 791   fclose (fp);
 792   if (pkey == NULL)
 793     ikev2_log_error ("read %s failed", file);
 794
 795 end:
 796   return pkey;
 797 }
 798
 799 void
 800 ikev2_crypto_init (ikev2_main_t * km)
 801 {
 802   ikev2_sa_transform_t *tr;
 803
 804   /* vector of supported transforms - in order of preference */
 805
 806   //Encryption
 807
 808   vec_add2 (km->supported_transforms, tr, 1);
 809   tr->type = IKEV2_TRANSFORM_TYPE_ENCR;
 810   tr->encr_type = IKEV2_TRANSFORM_ENCR_TYPE_AES_CBC;
 811   tr->key_len = 256 / 8;
 812   tr->block_size = 128 / 8;
 813   tr->cipher = EVP_aes_256_cbc ();
 814
 815   vec_add2 (km->supported_transforms, tr, 1);
 816   tr->type = IKEV2_TRANSFORM_TYPE_ENCR;
 817   tr->encr_type = IKEV2_TRANSFORM_ENCR_TYPE_AES_CBC;
 818   tr->key_len = 192 / 8;
 819   tr->block_size = 128 / 8;
 820   tr->cipher = EVP_aes_192_cbc ();
 821
 822   vec_add2 (km->supported_transforms, tr, 1);
 823   tr->type = IKEV2_TRANSFORM_TYPE_ENCR;
 824   tr->encr_type = IKEV2_TRANSFORM_ENCR_TYPE_AES_CBC;
 825   tr->key_len = 128 / 8;
 826   tr->block_size = 128 / 8;
 827   tr->cipher = EVP_aes_128_cbc ();
 828
 829   vec_add2 (km->supported_transforms, tr, 1);
 830   tr->type = IKEV2_TRANSFORM_TYPE_ENCR;
 831   tr->encr_type = IKEV2_TRANSFORM_ENCR_TYPE_AES_GCM_16;
 832   tr->key_len = 256 / 8;
 833   tr->block_size = 128 / 8;
 834   tr->cipher = EVP_aes_256_gcm ();
 835
 836   vec_add2 (km->supported_transforms, tr, 1);
 837   tr->type = IKEV2_TRANSFORM_TYPE_ENCR;
 838   tr->encr_type = IKEV2_TRANSFORM_ENCR_TYPE_AES_GCM_16;
 839   tr->key_len = 192 / 8;
 840   tr->block_size = 128 / 8;
 841   tr->cipher = EVP_aes_192_gcm ();
 842
 843   vec_add2 (km->supported_transforms, tr, 1);
 844   tr->type = IKEV2_TRANSFORM_TYPE_ENCR;
 845   tr->encr_type = IKEV2_TRANSFORM_ENCR_TYPE_AES_GCM_16;
 846   tr->key_len = 128 / 8;
 847   tr->block_size = 128 / 8;
 848   tr->cipher = EVP_aes_128_gcm ();
 849
 850   //PRF
 851   vec_add2 (km->supported_transforms, tr, 1);
 852   tr->type = IKEV2_TRANSFORM_TYPE_PRF;
 853   tr->prf_type = IKEV2_TRANSFORM_PRF_TYPE_PRF_HMAC_SHA2_256;
 854   tr->key_len = 256 / 8;
 855   tr->key_trunc = 256 / 8;
 856   tr->md = EVP_sha256 ();
 857
 858   vec_add2 (km->supported_transforms, tr, 1);
 859   tr->type = IKEV2_TRANSFORM_TYPE_PRF;
 860   tr->prf_type = IKEV2_TRANSFORM_PRF_TYPE_PRF_HMAC_SHA2_384;
 861   tr->key_len = 384 / 8;
 862   tr->key_trunc = 384 / 8;
 863   tr->md = EVP_sha384 ();
 864
 865   vec_add2 (km->supported_transforms, tr, 1);
 866   tr->type = IKEV2_TRANSFORM_TYPE_PRF;
 867   tr->prf_type = IKEV2_TRANSFORM_PRF_TYPE_PRF_HMAC_SHA2_512;
 868   tr->key_len = 512 / 8;
 869   tr->key_trunc = 512 / 8;
 870   tr->md = EVP_sha512 ();
 871
 872   vec_add2 (km->supported_transforms, tr, 1);
 873   tr->type = IKEV2_TRANSFORM_TYPE_PRF;
 874   tr->prf_type = IKEV2_TRANSFORM_PRF_TYPE_PRF_HMAC_SHA1;
 875   tr->key_len = 160 / 8;
 876   tr->key_trunc = 160 / 8;
 877   tr->md = EVP_sha1 ();
 878
 879   //Integrity
 880   vec_add2 (km->supported_transforms, tr, 1);
 881   tr->type = IKEV2_TRANSFORM_TYPE_INTEG;
 882   tr->integ_type = IKEV2_TRANSFORM_INTEG_TYPE_AUTH_HMAC_SHA2_256_128;
 883   tr->key_len = 256 / 8;
 884   tr->key_trunc = 128 / 8;
 885   tr->md = EVP_sha256 ();
 886
 887   vec_add2 (km->supported_transforms, tr, 1);
 888   tr->type = IKEV2_TRANSFORM_TYPE_INTEG;
 889   tr->integ_type = IKEV2_TRANSFORM_INTEG_TYPE_AUTH_HMAC_SHA2_384_192;
 890   tr->key_len = 384 / 8;
 891   tr->key_trunc = 192 / 8;
 892   tr->md = EVP_sha384 ();
 893
 894   vec_add2 (km->supported_transforms, tr, 1);
 895   tr->type = IKEV2_TRANSFORM_TYPE_INTEG;
 896   tr->integ_type = IKEV2_TRANSFORM_INTEG_TYPE_AUTH_HMAC_SHA2_512_256;
 897   tr->key_len = 512 / 8;
 898   tr->key_trunc = 256 / 8;
 899   tr->md = EVP_sha512 ();
 900
 901   vec_add2 (km->supported_transforms, tr, 1);
 902   tr->type = IKEV2_TRANSFORM_TYPE_INTEG;
 903   tr->integ_type = IKEV2_TRANSFORM_INTEG_TYPE_AUTH_HMAC_SHA1_160;
 904   tr->key_len = 160 / 8;
 905   tr->key_trunc = 160 / 8;
 906   tr->md = EVP_sha1 ();
 907
 908   vec_add2 (km->supported_transforms, tr, 1);
 909   tr->type = IKEV2_TRANSFORM_TYPE_INTEG;
 910   tr->integ_type = IKEV2_TRANSFORM_INTEG_TYPE_AUTH_HMAC_SHA1_96;
 911   tr->key_len = 160 / 8;
 912   tr->key_trunc = 96 / 8;
 913   tr->md = EVP_sha1 ();
 914
 915
 916 #if defined(OPENSSL_NO_CISCO_FECDH)
 917   vec_add2 (km->supported_transforms, tr, 1);
 918   tr->type = IKEV2_TRANSFORM_TYPE_DH;
 919   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_BRAINPOOL_512;
 920   tr->key_len = (512 * 2) / 8;
 921   tr->nid = NID_brainpoolP512r1;
 922   tr->dh_group = IKEV2_DH_GROUP_ECP;
 923
 924   vec_add2 (km->supported_transforms, tr, 1);
 925   tr->type = IKEV2_TRANSFORM_TYPE_DH;
 926   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_BRAINPOOL_384;
 927   tr->key_len = (384 * 2) / 8;
 928   tr->nid = NID_brainpoolP384r1;
 929   tr->dh_group = IKEV2_DH_GROUP_ECP;
 930
 931   vec_add2 (km->supported_transforms, tr, 1);
 932   tr->type = IKEV2_TRANSFORM_TYPE_DH;
 933   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_BRAINPOOL_256;
 934   tr->key_len = (256 * 2) / 8;
 935   tr->nid = NID_brainpoolP256r1;
 936   tr->dh_group = IKEV2_DH_GROUP_ECP;
 937
 938   vec_add2 (km->supported_transforms, tr, 1);
 939   tr->type = IKEV2_TRANSFORM_TYPE_DH;
 940   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_BRAINPOOL_224;
 941   tr->key_len = (224 * 2) / 8;
 942   tr->nid = NID_brainpoolP224r1;
 943   tr->dh_group = IKEV2_DH_GROUP_ECP;
 944
 945   vec_add2 (km->supported_transforms, tr, 1);
 946   tr->type = IKEV2_TRANSFORM_TYPE_DH;
 947   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_ECP_224;
 948   tr->key_len = (224 * 2) / 8;
 949   tr->nid = NID_secp224r1;
 950   tr->dh_group = IKEV2_DH_GROUP_ECP;
 951 #endif
 952
 953   vec_add2 (km->supported_transforms, tr, 1);
 954   tr->type = IKEV2_TRANSFORM_TYPE_DH;
 955   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_ECP_521;
 956   tr->key_len = (528 * 2) / 8;
 957   tr->nid = NID_secp521r1;
 958   tr->dh_group = IKEV2_DH_GROUP_ECP;
 959
 960   vec_add2 (km->supported_transforms, tr, 1);
 961   tr->type = IKEV2_TRANSFORM_TYPE_DH;
 962   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_ECP_384;
 963   tr->key_len = (384 * 2) / 8;
 964   tr->nid = NID_secp384r1;
 965   tr->dh_group = IKEV2_DH_GROUP_ECP;
 966
 967   vec_add2 (km->supported_transforms, tr, 1);
 968   tr->type = IKEV2_TRANSFORM_TYPE_DH;
 969   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_ECP_256;
 970   tr->key_len = (256 * 2) / 8;
 971   tr->nid = NID_X9_62_prime256v1;
 972   tr->dh_group = IKEV2_DH_GROUP_ECP;
 973
 974   vec_add2 (km->supported_transforms, tr, 1);
 975   tr->type = IKEV2_TRANSFORM_TYPE_DH;
 976   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_ECP_192;
 977   tr->key_len = (192 * 2) / 8;
 978   tr->nid = NID_X9_62_prime192v1;
 979   tr->dh_group = IKEV2_DH_GROUP_ECP;
 980
 981   vec_add2 (km->supported_transforms, tr, 1);
 982   tr->type = IKEV2_TRANSFORM_TYPE_DH;
 983   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_MODP_2048_256;
 984   tr->key_len = 2048 / 8;
 985   tr->dh_p = (const char *) &modp_dh_2048_256_prime;
 986   tr->dh_g = (const char *) &modp_dh_2048_256_generator;
 987   tr->dh_group = IKEV2_DH_GROUP_MODP;
 988
 989   vec_add2 (km->supported_transforms, tr, 1);
 990   tr->type = IKEV2_TRANSFORM_TYPE_DH;
 991   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_MODP_2048_224;
 992   tr->key_len = 2048 / 8;
 993   tr->dh_p = (const char *) &modp_dh_2048_224_prime;
 994   tr->dh_g = (const char *) &modp_dh_2048_224_generator;
 995   tr->dh_group = IKEV2_DH_GROUP_MODP;
 996
 997   vec_add2 (km->supported_transforms, tr, 1);
 998   tr->type = IKEV2_TRANSFORM_TYPE_DH;
 999   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_MODP_1024_160;
1000   tr->key_len = 1024 / 8;
1001   tr->dh_p = (const char *) &modp_dh_1024_160_prime;
1002   tr->dh_g = (const char *) &modp_dh_1024_160_generator;
1003   tr->dh_group = IKEV2_DH_GROUP_MODP;
1004
1005   vec_add2 (km->supported_transforms, tr, 1);
1006   tr->type = IKEV2_TRANSFORM_TYPE_DH;
1007   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_MODP_8192;
1008   tr->key_len = 8192 / 8;
1009   tr->dh_p = (const char *) &modp_dh_8192_prime;
1010   tr->dh_g = (const char *) &modp_dh_8192_generator;
1011   tr->dh_group = IKEV2_DH_GROUP_MODP;
1012
1013   vec_add2 (km->supported_transforms, tr, 1);
1014   tr->type = IKEV2_TRANSFORM_TYPE_DH;
1015   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_MODP_6144;
1016   tr->key_len = 6144 / 8;
1017   tr->dh_p = (const char *) &modp_dh_6144_prime;
1018   tr->dh_g = (const char *) &modp_dh_6144_generator;
1019   tr->dh_group = IKEV2_DH_GROUP_MODP;
1020
1021   vec_add2 (km->supported_transforms, tr, 1);
1022   tr->type = IKEV2_TRANSFORM_TYPE_DH;
1023   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_MODP_4096;
1024   tr->key_len = 4096 / 8;
1025   tr->dh_p = (const char *) &modp_dh_4096_prime;
1026   tr->dh_g = (const char *) &modp_dh_4096_generator;
1027   tr->dh_group = IKEV2_DH_GROUP_MODP;
1028
1029   vec_add2 (km->supported_transforms, tr, 1);
1030   tr->type = IKEV2_TRANSFORM_TYPE_DH;
1031   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_MODP_3072;
1032   tr->key_len = 3072 / 8;
1033   tr->dh_p = (const char *) &modp_dh_3072_prime;
1034   tr->dh_g = (const char *) &modp_dh_3072_generator;
1035   tr->dh_group = IKEV2_DH_GROUP_MODP;
1036
1037   vec_add2 (km->supported_transforms, tr, 1);
1038   tr->type = IKEV2_TRANSFORM_TYPE_DH;
1039   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_MODP_2048;
1040   tr->key_len = 2048 / 8;
1041   tr->dh_p = (const char *) &modp_dh_2048_prime;
1042   tr->dh_g = (const char *) &modp_dh_2048_generator;
1043   tr->dh_group = IKEV2_DH_GROUP_MODP;
1044
1045   vec_add2 (km->supported_transforms, tr, 1);
1046   tr->type = IKEV2_TRANSFORM_TYPE_DH;
1047   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_MODP_1536;
1048   tr->key_len = 1536 / 8;
1049   tr->dh_p = (const char *) &modp_dh_1536_prime;
1050   tr->dh_g = (const char *) &modp_dh_1536_generator;
1051   tr->dh_group = IKEV2_DH_GROUP_MODP;
1052
1053   vec_add2 (km->supported_transforms, tr, 1);
1054   tr->type = IKEV2_TRANSFORM_TYPE_DH;
1055   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_MODP_1024;
1056   tr->key_len = 1024 / 8;
1057   tr->dh_p = (const char *) &modp_dh_1024_prime;
1058   tr->dh_g = (const char *) &modp_dh_1024_generator;
1059   tr->dh_group = IKEV2_DH_GROUP_MODP;
1060
1061   vec_add2 (km->supported_transforms, tr, 1);
1062   tr->type = IKEV2_TRANSFORM_TYPE_DH;
1063   tr->dh_type = IKEV2_TRANSFORM_DH_TYPE_MODP_768;
1064   tr->key_len = 768 / 8;
1065   tr->dh_p = (const char *) &modp_dh_768_prime;
1066   tr->dh_g = (const char *) &modp_dh_768_generator;
1067   tr->dh_group = IKEV2_DH_GROUP_MODP;
1068
1069   vec_add2 (km->supported_transforms, tr, 1);
1070   tr->type = IKEV2_TRANSFORM_TYPE_ESN;
1071   tr->esn_type = IKEV2_TRANSFORM_ESN_TYPE_ESN;
1072
1073   vec_add2 (km->supported_transforms, tr, 1);
1074   tr->type = IKEV2_TRANSFORM_TYPE_ESN;
1075   tr->esn_type = IKEV2_TRANSFORM_ESN_TYPE_NO_ESN;
1076 }
1077
1078
1079
1080 /*
1081  * fd.io coding-style-patch-verification: ON
1082  *
1083  * Local Variables:
1084  * eval: (c-set-style "gnu")
1085  * End:
1086  */