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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
auth_priv.cpp
资源名称：snmp_pp.rar　[点击查看]
上传用户：ets1996
上传日期：2014-09-30
资源大小：353k
文件大小：61k
源码类别：

SNMP编程

开发平台：

Visual C++

auth_priv.cpp：源码内容
  1. /*_############################################################################
  2.   _## 
  3.   _##  auth_priv.cpp  
  4.   _##
  5.   _##  SNMP++v3.2.22
  6.   _##  -----------------------------------------------
  7.   _##  Copyright (c) 2001-2007 Jochen Katz, Frank Fock
  8.   _##
  9.   _##  This software is based on SNMP++2.6 from Hewlett Packard:
  10.   _##  
  11.   _##    Copyright (c) 1996
  12.   _##    Hewlett-Packard Company
  13.   _##  
  14.   _##  ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  15.   _##  Permission to use, copy, modify, distribute and/or sell this software 
  16.   _##  and/or its documentation is hereby granted without fee. User agrees 
  17.   _##  to display the above copyright notice and this license notice in all 
  18.   _##  copies of the software and any documentation of the software. User 
  19.   _##  agrees to assume all liability for the use of the software; 
  20.   _##  Hewlett-Packard and Jochen Katz make no representations about the 
  21.   _##  suitability of this software for any purpose. It is provided 
  22.   _##  "AS-IS" without warranty of any kind, either express or implied. User 
  23.   _##  hereby grants a royalty-free license to any and all derivatives based
  24.   _##  upon this software code base. 
  25.   _##  
  26.   _##  Stuttgart, Germany, Wed May  2 23:22:30 CEST 2007 
  27.   _##  
  28.   _##########################################################################*/
  29. char auth_priv_version[]="@(#) SNMP++ $Id: auth_priv.cpp 256 2006-06-03 20:16:00Z katz $";
  31. #include "snmp_pp/config_snmp_pp.h"
  33. #ifdef _SNMPv3
  35. #include <string.h>
  36. #include <stdlib.h>
  37. #include <time.h>
  39. // Only use DES, AES, SHA1 and MD5 from libtomcrypt if openssl is not used
  40. #if defined(_USE_LIBTOMCRYPT) && !defined(_USE_OPENSSL)
  41. #include <tomcrypt.h>
  42. #endif
  44. // Use DES, AES, SHA and MD5 from openssl
  45. #ifdef _USE_OPENSSL
  46. #include <openssl/des.h>
  47. #include <openssl/aes.h>
  48. #include <openssl/sha.h>
  49. #include <openssl/md5.h>
  50. #endif
  52. // Use internal functions for SHA and MD5 and libdes only
  53. // if not using libtomcrypt and openssl
  54. #if !defined(_USE_LIBTOMCRYPT) && !defined(_USE_OPENSSL)
  55. #include "snmp_pp/sha.h"
  56. #ifdef RSAEURO
  57. #include <rsaeuro.h>
  58. #else
  59. #include <des.h>
  60. #include "snmp_pp/md5.h"
  61. #endif
  62. #endif // !defined(_USE_LIBTOMCRYPT) && !defined(_USE_OPENSSL)
  64. // IDEA can only be used with a valid license
  65. #ifdef _USE_IDEA
  66. #include "snmp_pp/idea.h"
  67. #endif
  69. #include "snmp_pp/auth_priv.h"
  70. #include "snmp_pp/v3.h"
  71. #include "snmp_pp/snmperrs.h"
  72. #include "snmp_pp/address.h"
  73. #include "snmp_pp/log.h"
  75. #ifdef SNMP_PP_NAMESPACE
  76. namespace Snmp_pp {
  77. #endif
  79. /*-----------------[ defines for crypto libraries ]------------------*/
  81. #ifdef _USE_OPENSSL
  83. /* -- START: Defines for OpenSSL -- */
  84. typedef SHA_CTX               SHAHashStateType;
  85. #define SHA1_INIT(s)          SHA1_Init(s)
  86. #define SHA1_PROCESS(s, p, l) SHA1_Update(s, p, l)
  87. #define SHA1_DONE(s, k)       SHA1_Final(k, s)
  89. typedef MD5_CTX               MD5HashStateType;
  90. #define MD5_INIT(s)           MD5_Init(s)
  91. #define MD5_PROCESS(s, p, l)  MD5_Update(s, p, l)
  92. #define MD5_DONE(s, k)        MD5_Final(k, s)
  94. typedef des_key_schedule      DESCBCType;
  95. #define DES_CBC_START_ENCRYPT(c, iv, k, kl, r, s) 
  96.                  if (des_key_sched((C_Block*)(k), s) < 0) 
  97.                  { 
  98.    debugprintf(0, "Starting DES encryption failed."); 
  99.    return SNMPv3_USM_ERROR; 
  100.                  }
  101. #define DES_CBC_START_DECRYPT(c, iv, k, kl, r, s) 
  102.                  if (des_key_sched((C_Block*)(k), s) < 0) 
  103.                  { 
  104.    debugprintf(0, "Starting DES decryption failed."); 
  105.    return SNMPv3_USM_ERROR; 
  106.                  }
  108. #define DES_CBC_ENCRYPT(pt, ct, s, iv, l) 
  109.                         des_ncbc_encrypt(pt, ct, l, 
  110.                                          s, (C_Block*)(iv), DES_ENCRYPT)
  111. #define DES_CBC_DECRYPT(ct, pt, s, iv, l) 
  112.                         des_ncbc_encrypt(ct, pt, l, 
  113.                                          s, (C_Block*)(iv), DES_DECRYPT)
  115. #define DES_EDE3_CBC_ENCRYPT(pt, ct, l, k1, k2, k3, iv) 
  116.                des_ede3_cbc_encrypt(pt, ct, l, 
  117.                                     k1, k2, k3, (C_Block*)(iv), DES_ENCRYPT)
  119. #define DES_EDE3_CBC_DECRYPT(ct, pt, l, k1, k2, k3, iv) 
  120.                des_ede3_cbc_encrypt(ct, pt, l, 
  121.                                     k1, k2, k3, (C_Block*)(iv), DES_DECRYPT)
  123. #define DES_MEMSET(s, c, l)   memset(&(s), c, l)
  125. /* -- END: Defines for OpenSSL -- */
  127. #else
  129. #ifdef _USE_LIBTOMCRYPT
  131. /* -- START: Defines for LibTomCrypt -- */
  132. typedef hash_state            SHAHashStateType;
  133. #define SHA1_INIT(s)          sha1_init(s)
  134. #define SHA1_PROCESS(s, p, l) sha1_process(s, p, l)
  135. #define SHA1_DONE(s, k)       sha1_done(s, k)
  137. typedef hash_state            MD5HashStateType;
  138. #define MD5_INIT(s)           md5_init(s)
  139. #define MD5_PROCESS(s, p, l)  md5_process(s, p, l)
  140. #define MD5_DONE(s, k)        md5_done(s, k)
  142. typedef symmetric_CBC         DESCBCType;
  143. #define DES_CBC_START_ENCRYPT(c, iv, k, kl, r, s) 
  144.                  if (cbc_start(c, iv, k, kl, r, &(s)) != CRYPT_OK) 
  145.                  { 
  146.    debugprintf(0, "Starting DES encryption failed."); 
  147.    return SNMPv3_USM_ERROR; 
  148.                  }
  150. #define DES_CBC_START_DECRYPT(c, iv, k, kl, r, s) 
  151.                  if (cbc_start(c, iv, k, kl, r, &(s)) != CRYPT_OK) 
  152.                  { 
  153.    debugprintf(0, "Starting DES decryption failed."); 
  154.    return SNMPv3_USM_ERROR; 
  155.                  }
  157. #define DES_CBC_ENCRYPT(pt, ct, s, iv, l) 
  158.                  if (cbc_encrypt(pt, ct, l, &(s)) != CRYPT_OK) 
  159.                  { 
  160.    debugprintf(0, "Error during DES encryption."); 
  161.    return SNMPv3_USM_ERROR; 
  162.                  }
  163. #define DES_CBC_DECRYPT(ct, pt, s, iv, l) 
  164.                  if (cbc_decrypt(ct, pt, l, &(s)) != CRYPT_OK) 
  165.                  { 
  166.    debugprintf(0, "Error during DES decryption."); 
  167.    return SNMPv3_USM_ERROR; 
  168.                  }
  169. #define DES_MEMSET(s, c, l)   memset(&(s), c, l)
  170. /* -- END: Defines for LibTomCrypt -- */
  172. #else // _USE_LIBTOMCRYPT  --> libdes
  174. /* -- START: Defines for libdes -- */
  176. typedef SHA_CTX               SHAHashStateType;
  177. #define SHA1_INIT(s)          SHAInit(s)
  178. #define SHA1_PROCESS(s, p, l) SHAUpdate(s, p, l)
  179. #define SHA1_DONE(s, k)       SHAFinal(k, s)
  181. typedef MD5_CTX               MD5HashStateType;
  182. #define MD5_INIT(s)           MD5Init(s)
  183. #define MD5_PROCESS(s, p, l)  MD5Update(s, p, l)
  184. #define MD5_DONE(s, k)        MD5Final(k, s)
  186. #define DES_EDE3_CBC_ENCRYPT(pt, ct, l, k1, k2, k3, iv) 
  187.                des_ede3_cbc_encrypt((C_Block*)(pt), (C_Block*)(ct), l, 
  188.                                     k1, k2, k3, (C_Block*)(iv), DES_ENCRYPT)
  190. #define DES_EDE3_CBC_DECRYPT(ct, pt, l, k1, k2, k3, iv) 
  191.                des_ede3_cbc_encrypt((C_Block*)(ct), (C_Block*)(pt), l, 
  192.                                     k1, k2, k3, (C_Block*)(iv), DES_DECRYPT)
  194. #ifdef RSAEURO
  196. #undef  MD5_PROCESS
  197. #define MD5_PROCESS(s, p, l)  MD5Update(s, (unsigned char*)(p), l)
  199. typedef DES_CBC_CTX           DESCBCType;
  200. #define DES_CBC_START_ENCRYPT(c, iv, k, kl, r, s) 
  201.                               DES_CBCInit(&(s), (unsigned char*)(k), iv, 1)
  202. #define DES_CBC_START_DECRYPT(c, iv, k, kl, r, s) 
  203.                               DES_CBCInit(&(s),(unsigned char*)(k), iv, 0)
  204. #define DES_CBC_ENCRYPT(pt, ct, s, iv, l) DES_CBCUpdate(&(s), pt, ct, l)
  205. #define DES_CBC_DECRYPT(ct, pt, s, iv, l) DES_CBCUpdate(&(s), (unsigned char*)(ct), pt, l)
  206. #define DES_MEMSET(s, c, l)   R_memset((POINTER)&(s), c, l)
  208. #else // RSAEURO
  210. typedef des_key_schedule      DESCBCType;
  211. #define DES_CBC_START_ENCRYPT(c, iv, k, kl, r, s) 
  212.                  if (des_key_sched((C_Block*)(k), s) < 0) 
  213.                  { 
  214.    debugprintf(0, "Starting DES encryption failed."); 
  215.    return SNMPv3_USM_ERROR; 
  216.                  }
  217. #define DES_CBC_START_DECRYPT(c, iv, k, kl, r, s) 
  218.                  if (des_key_sched((C_Block*)(k), s) < 0) 
  219.                  { 
  220.    debugprintf(0, "Starting DES decryption failed."); 
  221.    return SNMPv3_USM_ERROR; 
  222.                  }
  224. #define DES_CBC_ENCRYPT(pt, ct, s, iv, l) 
  225.                         des_ncbc_encrypt((C_Block*)(pt), (C_Block*)(ct), l, 
  226.                                          s, (C_Block*)(iv), DES_ENCRYPT)
  227. #define DES_CBC_DECRYPT(ct, pt, s, iv, l) 
  228.                         des_ncbc_encrypt((C_Block*)(ct), (C_Block*)(pt), l, 
  229.                                          s, (C_Block*)(iv), DES_DECRYPT)
  230. #define DES_MEMSET(s, c, l)   memset(&(s), c, l)
  232. /* -- END: Defines for libdes -- */
  234. #endif // RSAEURO
  236. #endif // _USE_LIBTOMCRYPT
  238. #endif // _USE_OPENSSL
  240. AuthPriv::AuthPriv(int &construct_state)
  241. {
  242.   auth = new AuthPtr[10];
  243.   priv = new PrivPtr[10];
  245.   if (auth)
  246.     auth_size = 10;
  247.   else
  248.   {
  249.     auth_size = 0;
  251.     LOG_BEGIN(ERROR_LOG | 1);
  252.     LOG("AuthPriv: Error allocating array for authentication.");
  253.     LOG_END;
  254.   }
  256.   if (priv)
  257.     priv_size = 10;
  258.   else
  259.   {
  260.     priv_size = 0;
  262.     LOG_BEGIN(ERROR_LOG | 1);
  263.     LOG("AuthPriv: Error allocating array for privacy.");
  264.     LOG_END;
  265.   }
  267.   for (int i = 0; i < auth_size; i++)
  268.     auth[i] = 0;
  270.   for (int j = 0; j < priv_size; j++)
  271.     priv[j] = 0;
  273.   /* Check size of salt, has to be 64 bits */
  274.   if (sizeof(salt) != 8)
  275.   {
  276.     LOG_BEGIN(ERROR_LOG | 1);
  277.     LOG("AuthPriv: *BUG* sizeof(pp_uint64) is not 8 bytes. snmp++ has to be patched for this system.");
  278.     LOG_END;
  280.     construct_state = SNMPv3_USM_ERROR;
  281.     return;
  282.   }
  284.   /* Initialize salt. srand() has been already done in Snmp::init() */
  285.   unsigned int *rnd = (unsigned int*)&salt;
  286.   *rnd = rand() << 1;
  287.   if (rand() < (RAND_MAX / 2))
  288.     *rnd += 1;
  289.   rnd++;
  290.   *rnd = rand() << 1;
  291.   if (rand() < (RAND_MAX / 2))
  292.     *rnd += 1;
  294.   construct_state = SNMPv3_USM_OK;
  296. #if defined(_USE_LIBTOMCRYPT) && !defined(_USE_OPENSSL)
  297.   /* register needed hashes and ciphers in libtomcrypt */
  298.   if (register_cipher(&rijndael_desc) < 0)
  299.   {
  300.     LOG_BEGIN(ERROR_LOG | 1);
  301.     LOG("AuthPriv: Error registering Rijndael.");
  302.     LOG_END;
  304.     construct_state = SNMPv3_USM_ERROR;
  305.   }
  307.   if (register_cipher(&des_desc) < 0)
  308.   {
  309.     LOG_BEGIN(ERROR_LOG | 1);
  310.     LOG("AuthPriv: Error registering DES.");
  311.     LOG_END;
  313.     construct_state = SNMPv3_USM_ERROR;
  314.   }
  316.   if (register_cipher(&des3_desc) < 0)
  317.   {
  318.     LOG_BEGIN(ERROR_LOG | 1);
  319.     LOG("AuthPriv: Error registering 3DES.");
  320.     LOG_END;
  322.     construct_state = SNMPv3_USM_ERROR;
  323.   }
  325.   if (register_hash(&sha1_desc) < 0)
  326.   {
  327.     LOG_BEGIN(ERROR_LOG | 1);
  328.     LOG("AuthPriv: Error registering SHA1.");
  329.     LOG_END;
  331.     construct_state = SNMPv3_USM_ERROR;
  332.   }
  334.   if (register_hash(&md5_desc) < 0)
  335.   {
  336.     LOG_BEGIN(ERROR_LOG | 1);
  337.     LOG("AuthPriv: Error registering MD5.");
  338.     LOG_END;
  340.     construct_state = SNMPv3_USM_ERROR;
  341.   }
  342. #endif // defined(_USE_LIBTOMCRYPT) && !defined(_USE_OPENSSL)
  343. }
  345. AuthPriv::~AuthPriv()
  346. {
  347.   for (int i = 0; i < auth_size; i++)
  348.     if (auth[i])
  349.     {
  350.       delete auth[i];
  351.       auth[i] = 0;
  352.     }
  354.   for (int j = 0; j < priv_size; j++)
  355.     if (priv[j])
  356.     {
  357.       delete priv[j];
  358.       priv[j] = 0;
  359.     }
  361.   delete [] auth;
  362.   delete [] priv;
  363. }
  365. int AuthPriv::add_auth(Auth *new_auth)
  366. {
  367.   if (!new_auth)
  368.   {
  369.     return SNMP_CLASS_ERROR;
  370.   }
  372.   int id = new_auth->get_id();
  374.   if (id < 0)
  375.   {
  376.     return SNMP_CLASS_ERROR;
  377.   }
  379.   if (id >= auth_size)
  380.   {
  381.     AuthPtr *new_array = new AuthPtr[id + 5];
  382.     if (!new_array)
  383.     {
  384.       LOG_BEGIN(ERROR_LOG | 1);
  385.       LOG("AuthPriv: Could not allocate new auth array.");
  386.       LOG_END;
  388.       return SNMP_CLASS_ERROR;
  389.     }
  390.     for (int i=0 ; i<auth_size; i++)
  391.       new_array[i] = auth[i];
  393.     for (int j=auth_size ; j<id + 5; j++)
  394.       new_array[j] = 0;
  396.     AuthPtr *victim = auth;
  397.     auth = new_array;
  398.     delete [] victim;
  399.     auth_size = id + 5;
  400.   }
  402.   new_auth->set_salt(&salt);
  404.   if (auth[id])
  405.   {
  406.     LOG_BEGIN(WARNING_LOG | 4);
  407.     LOG("AuthPriv: deleting old auth object before adding new one (id)");
  408.     LOG(id);
  409.     LOG_END;
  411.     delete auth[id];
  412.   }
  414.   auth[id] = new_auth;
  416.   LOG_BEGIN(INFO_LOG | 6);
  417.   LOG("AuthPriv: Added auth protocol (id)");
  418.   LOG(id);
  419.   LOG_END;
  421.   return SNMP_CLASS_SUCCESS;
  422. }
  424. int AuthPriv::del_auth(const int auth_id)
  425. {
  426.   if ((auth_id < 0) || (auth_id >= auth_size) || (auth[auth_id] == 0))
  427.   {
  428.     LOG_BEGIN(WARNING_LOG | 4);
  429.     LOG("AuthPriv: Request to delete non existing auth protocol (id)");
  430.     LOG(auth_id);
  431.     LOG_END;
  433.     return SNMP_CLASS_ERROR;
  434.   }
  436.   delete auth[auth_id];
  437.   auth[auth_id] = 0;
  439.   LOG_BEGIN(INFO_LOG | 6);
  440.   LOG("AuthPriv: Removed auth protocol (id)");
  441.   LOG(auth_id);
  442.   LOG_END;
  444.   return SNMP_CLASS_SUCCESS;
  445. }
  448. int AuthPriv::add_priv(Priv *new_priv)
  449. {
  450.   if (!new_priv)
  451.   {
  452.     return SNMP_CLASS_ERROR;
  453.   }
  455.   int id = new_priv->get_id();
  457.   if (id < 0)
  458.   {
  459.     return SNMP_CLASS_ERROR;
  460.   }
  462.   if (id >= priv_size)
  463.   {
  464.     PrivPtr *new_array = new PrivPtr[id + 5];
  465.     if (!new_array)
  466.     {
  467.       LOG_BEGIN(ERROR_LOG | 1);
  468.       LOG("AuthPriv: Could not allocate new priv array.");
  469.       LOG_END;
  471.       return SNMP_CLASS_ERROR;
  472.     }
  473.     for (int i=0 ; i<priv_size; i++)
  474.       new_array[i] = priv[i];
  476.     for (int j=priv_size ; j<id + 5; j++)
  477.       new_array[j] = 0;
  479.     PrivPtr *victim = priv;
  480.     priv = new_array;
  481.     delete [] victim;
  482.     priv_size = id + 5;
  483.   }
  485.   new_priv->set_salt(&salt);
  487.   if (priv[id])
  488.   {
  489.     LOG_BEGIN(WARNING_LOG | 4);
  490.     LOG("AuthPriv: deleting old priv object before adding new one (id)");
  491.     LOG(id);
  492.     LOG_END;
  494.     delete priv[id];
  495.   }
  497.   priv[id] = new_priv;
  499.   LOG_BEGIN(INFO_LOG | 6);
  500.   LOG("AuthPriv: Added priv protocol (id)");
  501.   LOG(id);
  502.   LOG_END;
  504.   return SNMP_CLASS_SUCCESS;
  505. }
  507. int AuthPriv::del_priv(const int priv_id)
  508. {
  509.   if ((priv_id < 0) || (priv_id >= priv_size) || (priv[priv_id] == 0))
  510.   {
  511.     LOG_BEGIN(WARNING_LOG | 4);
  512.     LOG("AuthPriv: Request to delete non existing priv protocol (id)");
  513.     LOG(priv_id);
  514.     LOG_END;
  516.     return SNMP_CLASS_ERROR;
  517.   }
  519.   delete priv[priv_id];
  520.   priv[priv_id] = 0;
  522.   LOG_BEGIN(INFO_LOG | 6);
  523.   LOG("AuthPriv: Removed priv protocol (id)");
  524.   LOG(priv_id);
  525.   LOG_END;
  527.   return SNMP_CLASS_SUCCESS;
  528. }
  530. Auth *AuthPriv::get_auth(const int auth_prot)
  531. {
  532.   if ((auth_prot >= 0) && (auth_prot < auth_size))
  533.     return auth[auth_prot];
  534.   return 0;
  535. }
  537. Priv *AuthPriv::get_priv(const int priv_prot)
  538. {
  539.   if ((priv_prot >= 0) && (priv_prot < priv_size))
  540.     return priv[priv_prot];
  541.   return 0;
  542. }
  544. // Get the unique id for the given auth protocol.
  545. int AuthPriv::get_auth_id(const char *string_id) const
  546. {
  547.   for (int i = 0; i < auth_size; ++i)
  548.     if ((auth[i]) && (strcmp(string_id, auth[i]->get_id_string()) == 0))
  549.       return i;
  550.   return -1;
  551. }
  553. // Get the unique id for the given priv protocol.
  554. int AuthPriv::get_priv_id(const char *string_id) const
  555. {
  556.   for (int i = 0; i < priv_size; ++i)
  557.     if ((priv[i]) && (strcmp(string_id, priv[i]->get_id_string()) == 0))
  558.       return i;
  559.   return -1;
  560. }
  562. int AuthPriv::get_keychange_value(const int       auth_prot,
  563.                                   const OctetStr& old_key,
  564.                                   const OctetStr& new_key,
  565.                                   OctetStr&       keychange_value)
  566. {
  568.   // uses fixed key length determined from oldkey!
  569.   // works with SHA and MD5
  570.   // modifications needed to support variable length keys
  571.   // algorithm according to USM-document textual convention KeyChange
  573.   int key_len = old_key.len();
  575.   Auth *a = get_auth(auth_prot);
  577.   if (!a)
  578.     return SNMPv3_USM_UNSUPPORTED_AUTHPROTOCOL;
  580.   // compute random value
  581.   OctetStr random = "";
  583.   for (int i=0; i<key_len; i++) {
  584. #ifdef _TEST
  585.     // do not use random values for testing
  586.     random += OctetStr((unsigned char*)"",1);
  587. #else
  588.     char tmprand = rand();
  589.     random += tmprand;
  590. #endif
  591.   }
  593. #ifdef __DEBUG
  594.   debugprintf(21, "Values for keyChange:");
  595.   debughexcprintf(21, "old_key", old_key.data(), old_key.len());
  596.   debughexcprintf(21, "new_key", new_key.data(), new_key.len());
  597.   debughexcprintf(21, "random value", random.data(), random.len());
  598. #endif
  600.   // step 1: initialize temporary variable
  601.   OctetStr tmp = old_key;
  603.   // step 2: nothing to do as we only support fixed length keys ;-)
  604.   // step 3:
  605.   tmp += random;
  606.   unsigned char digest[SNMPv3_USM_MAX_KEY_LEN];
  607.   memset((char*)digest, 0, SNMPv3_USM_MAX_KEY_LEN);
  609.   a->hash(tmp.data(), tmp.len(), digest);
  611.   // step 4:
  612.   keychange_value = random;
  613.   keychange_value += new_key;
  614.   for (unsigned int j = key_len; j < keychange_value.len(); j++) {
  615.     keychange_value[j] = keychange_value[j] ^ digest[j - key_len];
  616.   }
  618. #ifdef __DEBUG
  619.   debughexcprintf(21, "keychange_value",
  620.                   keychange_value.data(), keychange_value.len());
  621. #endif
  623.   return SNMPv3_USM_OK;
  624. }
  626. int AuthPriv::password_to_key_auth(const int            auth_prot,
  627.                                    const unsigned char *password,
  628.                                    const unsigned int   password_len,
  629.                                    const unsigned char *engine_id,
  630.                                    const unsigned int   engine_id_len,
  631.                                    unsigned char *key,
  632.                                    unsigned int  *key_len)
  633. {
  634.   if (auth_prot == SNMP_AUTHPROTOCOL_NONE)
  635.   {
  636.     *key_len = 0;
  637.     return SNMPv3_USM_OK;
  638.   }
  640.   if (!password || (password_len == 0))
  641.   {
  642.     LOG_BEGIN(WARNING_LOG | 2);
  643.     LOG("AuthPriv: Password to key auth needs a non empty password");
  644.     LOG_END;
  646.     return SNMPv3_USM_ERROR;
  647.   }
  649.   Auth *a = get_auth(auth_prot);
  651.   if (!a)
  652.     return SNMPv3_USM_UNSUPPORTED_AUTHPROTOCOL;
  654.   int res = a->password_to_key(password, password_len,
  655.                                engine_id, engine_id_len,
  656.                                key, key_len);
  658.   return res;
  659. }
  662. int AuthPriv::password_to_key_priv(const int            auth_prot,
  663.                                    const int            priv_prot,
  664.                                    const unsigned char *password,
  665.                                    const unsigned int   password_len,
  666.                                    const unsigned char *engine_id,
  667.                                    const unsigned int   engine_id_len,
  668.                                    unsigned char *key,
  669.                                    unsigned int  *key_len)
  670. {
  671.   /* check for priv protocol */
  672.   if (priv_prot == SNMP_PRIVPROTOCOL_NONE)
  673.   {
  674.     *key_len = 0;
  675.     return SNMPv3_USM_OK;
  676.   }
  678.   if (!password || (password_len == 0))
  679.   {
  680.     LOG_BEGIN(WARNING_LOG | 2);
  681.     LOG("AuthPriv: Password to key priv needs a non empty password");
  682.     LOG_END;
  684.     return SNMPv3_USM_ERROR;
  685.   }
  687.   Priv *p = get_priv(priv_prot);
  688.   Auth *a = get_auth(auth_prot);
  690.   if (!p)  return SNMPv3_USM_UNSUPPORTED_PRIVPROTOCOL;
  691.   if (!a)  return SNMPv3_USM_UNSUPPORTED_AUTHPROTOCOL;
  693.   unsigned int max_key_len = *key_len; /* save length of buffer! */
  694.   unsigned int min_key_len = p->get_min_key_len();
  696.   /* check if buffer for key is long enough */
  697.   if (min_key_len > max_key_len)
  698.     return SNMPv3_USM_ERROR; // TODO: better error code!
  700.   int res = password_to_key_auth(auth_prot,
  701.  password, password_len,
  702.  engine_id, engine_id_len,
  703.  key, key_len);
  704.   if (res != SNMPv3_USM_OK)
  705.     return res;
  707.   /* We have a too short key: Call priv protocoll to extend it */
  708.   if (*key_len < min_key_len)
  709.   {
  710.     res = p->extend_short_key(password, password_len,
  711.       engine_id, engine_id_len,
  712.       key, key_len, max_key_len, a);
  713.     if (res != SNMPv3_USM_OK)
  714.       return res;
  715.   }
  717.   /* make sure key length is valid */
  718.   p->fix_key_len(*key_len);
  720.   return SNMPv3_USM_OK;
  721. }
  726. int AuthPriv::encrypt_msg(const int            priv_prot,
  727.                           const unsigned char *key,
  728.                           const unsigned int   key_len,
  729.                           const unsigned char *buffer,
  730.                           const unsigned int   buffer_len,
  731.                           unsigned char       *out_buffer,
  732.                           unsigned int        *out_buffer_len,
  733.                           unsigned char       *privacy_params,
  734.                           unsigned int        *privacy_params_len,
  735.                           const unsigned long  engine_boots,
  736.                           const unsigned long  engine_time)
  737. {
  738.   /* check for priv protocol */
  739.   Priv *p = get_priv(priv_prot);
  741.   if (!p)
  742.     return SNMPv3_USM_UNSUPPORTED_PRIVPROTOCOL;
  744.   return p->encrypt(key, key_len, buffer, buffer_len,
  745.                     out_buffer, out_buffer_len,
  746.                     privacy_params, privacy_params_len,
  747.                     engine_boots, engine_time);
  748. }
  750. int AuthPriv::decrypt_msg(const int            priv_prot,
  751.                           const unsigned char *key,
  752.                           const unsigned int   key_len,
  753.                           const unsigned char *buffer,
  754.                           const unsigned int   buffer_len,
  755.                           unsigned char       *out_buffer,
  756.                           unsigned int        *out_buffer_len,
  757.                           const unsigned char *privacy_params,
  758.                           const unsigned int   privacy_params_len,
  759.   const unsigned long  engine_boots,
  760.   const unsigned long  engine_time)
  761. {
  762.   /* check for priv protocol */
  763.   Priv *p = get_priv(priv_prot);
  765.   if (!p)
  766.     return SNMPv3_USM_UNSUPPORTED_PRIVPROTOCOL;
  768.   return p->decrypt(key, key_len, buffer, buffer_len,
  769.                     out_buffer, out_buffer_len,
  770.                     privacy_params, privacy_params_len,
  771.     engine_boots, engine_time);
  772. }
  775. int AuthPriv::add_default_modules()
  776. {
  777.   int ret = SNMP_CLASS_SUCCESS;
  779.   if (add_auth(new AuthSHA()) != SNMP_ERROR_SUCCESS)
  780.   {
  781.     LOG_BEGIN(ERROR_LOG | 1);
  782.     LOG("AuthPriv: Could not add default protocol AuthSHA.");
  783.     LOG_END;
  785.     ret = SNMP_CLASS_ERROR;
  786.   }
  788.   if (add_auth(new AuthMD5()) != SNMP_ERROR_SUCCESS)
  789.   {
  790.     LOG_BEGIN(ERROR_LOG | 1);
  791.     LOG("AuthPriv: Could not add default protocol AuthMD5.");
  792.     LOG_END;
  794.     ret = SNMP_CLASS_ERROR;
  795.   }
  797.   if (add_priv(new PrivDES()) != SNMP_ERROR_SUCCESS)
  798.   {
  799.     LOG_BEGIN(ERROR_LOG | 1);
  800.     LOG("AuthPriv: Could not add default protocol PrivDES.");
  801.     LOG_END;
  803.     ret = SNMP_CLASS_ERROR;
  804.   }
  806. #ifdef _USE_IDEA
  807.   if (add_priv(new PrivIDEA()) != SNMP_ERROR_SUCCESS)
  808.   {
  809.     LOG_BEGIN(ERROR_LOG | 1);
  810.     LOG("AuthPriv: Could not add default protocol PrivIDEA.");
  811.     LOG_END;
  813.     ret = SNMP_CLASS_ERROR;
  814.   }
  815. #endif
  817. #if defined(_USE_LIBTOMCRYPT) || defined(_USE_OPENSSL)
  818.   if (add_priv(new PrivAES(SNMP_PRIVPROTOCOL_AES128)) != SNMP_ERROR_SUCCESS)
  819.   {
  820.     LOG_BEGIN(ERROR_LOG | 1);
  821.     LOG("AuthPriv: Could not add default protocol PrivAES 128.");
  822.     LOG_END;
  824.     ret = SNMP_CLASS_ERROR;
  825.   }
  827.   if (add_priv(new PrivAES(SNMP_PRIVPROTOCOL_AES192)) != SNMP_ERROR_SUCCESS)
  828.   {
  829.     LOG_BEGIN(ERROR_LOG | 1);
  830.     LOG("AuthPriv: Could not add default protocol PrivAES 192.");
  831.     LOG_END;
  833.     ret = SNMP_CLASS_ERROR;
  834.   }
  836.   if (add_priv(new PrivAES(SNMP_PRIVPROTOCOL_AES256)) != SNMP_ERROR_SUCCESS)
  837.   {
  838.     LOG_BEGIN(ERROR_LOG | 1);
  839.     LOG("AuthPriv: Could not add default protocol PrivAES 256.");
  840.     LOG_END;
  842.     ret = SNMP_CLASS_ERROR;
  843.   }
  844. #endif
  846. #ifdef _USE_3DES_EDE
  847.   if (add_priv(new Priv3DES_EDE()) != SNMP_ERROR_SUCCESS)
  848.   {
  849.     LOG_BEGIN(ERROR_LOG | 1);
  850.     LOG("AuthPriv: Could not add default protocol Priv3DES_EDE.");
  851.     LOG_END;
  853.     ret = SNMP_CLASS_ERROR;
  854.   }
  855. #endif
  858.   if (ret == SNMP_CLASS_SUCCESS)
  859.   {
  860.     LOG_BEGIN(INFO_LOG | 3);
  861.     LOG("AuthPriv: Added default Auth and Priv protocols.");
  862.     LOG_END;
  863.   }
  865.   return ret;
  866. }
  868. int AuthPriv::get_auth_params_len(const int auth_prot)
  869. {
  870.   Auth *a = get_auth(auth_prot);
  872.   if (!a)
  873.     return 0;
  875.   return a->get_auth_params_len();
  876. }
  878. int AuthPriv::get_priv_params_len(const int priv_prot)
  879. {
  880.   Priv *p = get_priv(priv_prot);
  882.   if (!p)
  883.     return 0;
  885.   return p->get_priv_params_len();
  886. }
  888. int AuthPriv::auth_out_msg(const int            auth_prot,
  889.                            const unsigned char *key,
  890.                            unsigned char       *msg,
  891.                            const int            msg_len,
  892.                            unsigned char       *auth_par_ptr)
  893. {
  894.   if (auth_prot == SNMP_AUTHPROTOCOL_NONE)
  895.     return SNMPv3_USM_UNSUPPORTED_SECURITY_LEVEL;
  897.   Auth *a = get_auth(auth_prot);
  899.   if (!a)
  900.     return SNMPv3_USM_UNSUPPORTED_AUTHPROTOCOL;
  902.   return a->auth_out_msg(key, msg, msg_len, auth_par_ptr);
  903. }
  905. int AuthPriv::auth_inc_msg(const int            auth_prot,
  906.                            const unsigned char *key,
  907.                            unsigned char       *msg,
  908.                            const int            msg_len,
  909.                            unsigned char       *auth_par_ptr,
  910.                            const int            auth_par_len)
  911. {
  912.   if (auth_prot == SNMP_AUTHPROTOCOL_NONE)
  913.     return SNMPv3_USM_UNSUPPORTED_SECURITY_LEVEL;
  915.   Auth *a = get_auth(auth_prot);
  917.   if (!a)
  918.     return SNMPv3_USM_UNSUPPORTED_AUTHPROTOCOL;
  920.   /* @todo check if auth par is inside msg
  921.   if ((auth_par_ptr < msg) ||
  922.       (msg + msg_len < auth_par_ptr + auth_par_len))
  923.   {
  924.     LOG_BEGIN(WARNING_LOG | 1);
  925.     LOG("AuthPriv: Authentication data is not within message (msg start) (len) (auth start) (len)");
  926.     LOG(msg);
  927.     LOG(msg_len);
  928.     LOG(auth_par_ptr);
  929.     LOG(auth_par_len);
  930.     LOG_END;
  932.     return SNMPv3_USM_ERROR;
  933.   }
  934.   */
  936.   return a->auth_inc_msg(key, msg, msg_len, auth_par_ptr, auth_par_len);
  937. }
  939. /* ========================================================== */
  941. /* ----------------------- AuthSHA ---------------------------------------*/
  943. int AuthSHA::password_to_key(const unsigned char *password,
  944.                              const unsigned int   password_len,
  945.                              const unsigned char *engine_id,
  946.                              const unsigned int   engine_id_len,
  947.                              unsigned char *key,
  948.                              unsigned int *key_len)
  949. {
  950.   *key_len = 20; /* All SHA keys have 20 bytes length */
  952. #ifdef __DEBUG
  953.   debugprintf(5,"password_to_key SHA: password: (%s).",
  954.       OctetStr(password, password_len).get_printable());
  955.   debugprintf(5,"password_to_key SHA: engine_id: (%s).",
  956.       OctetStr(engine_id, engine_id_len).get_printable());
  957. #endif
  959.   SHAHashStateType sha_hash_state;
  960.   unsigned char *cp, password_buf[72];
  961.   unsigned long  password_index = 0;
  962.   unsigned long  count = 0, i;
  964.   SHA1_INIT(&sha_hash_state);   /* initialize SHA */
  966.   /**********************************************/
  967.   /* Use while loop until we've done 1 Megabyte */
  968.   /**********************************************/
  969.   while (count < 1048576) {
  970.     cp = password_buf;
  971.     for (i = 0; i < 64; i++) {
  972.       /*************************************************/
  973.       /* Take the next octet of the password, wrapping */
  974.       /* to the beginning of the password as necessary.*/
  975.       /*************************************************/
  976.       *cp++ = password[password_index++ % password_len];
  977.     }
  979.     SHA1_PROCESS(&sha_hash_state, password_buf, 64);
  980.     count += 64;
  981.   }
  983.   SHA1_DONE(&sha_hash_state, key);          /* tell SHA we're done */
  985. #ifdef __DEBUG
  986.   debughexcprintf(21, "key", key, *key_len);
  987. #endif
  989.   /*****************************************************/
  990.   /* Now localize the key with the engine_id and pass  */
  991.   /* through SHA to produce final key                  */
  992.   /* May want to ensure that engine_id_len <= 32,      */
  993.   /* otherwise need to use a buffer larger than 72     */
  994.   /*****************************************************/
  995.   memcpy(password_buf,                            key,       *key_len);
  996.   memcpy(password_buf + *key_len,                 engine_id, engine_id_len);
  997.   memcpy(password_buf + *key_len + engine_id_len, key,       *key_len);
  999.   SHA1_INIT(&sha_hash_state);
  1000.   SHA1_PROCESS(&sha_hash_state, password_buf, (2 * *key_len) + engine_id_len);
  1001.   SHA1_DONE(&sha_hash_state, key);
  1003. #ifdef __DEBUG
  1004.   debughexcprintf(21, "localized key", key, *key_len);
  1005. #endif
  1007.   return SNMPv3_USM_OK;
  1008. }
  1010. int AuthSHA::hash(const unsigned char *data,
  1011.                   const unsigned int   data_len,
  1012.                   unsigned char       *digest) const
  1013. {
  1014.   SHAHashStateType sha_hash_state;
  1016.   SHA1_INIT(&sha_hash_state);
  1017.   SHA1_PROCESS(&sha_hash_state, data, data_len);
  1018.   SHA1_DONE(&sha_hash_state, digest);
  1020.   return SNMPv3_USM_OK;
  1021. }
  1023. int AuthSHA::auth_out_msg(const unsigned char *key,
  1024.                           unsigned char *msg,
  1025.                           const int msg_len,
  1026.                           unsigned char *auth_par_ptr)
  1027. {
  1028.   SHAHashStateType sha_hash_state;
  1029.   int           key_len = 20; /* We use only 20 Byte Key! */
  1030.   unsigned char digest[20];
  1031.   unsigned char k_ipad[65];   /* inner padding - key XORd with ipad */
  1032.   unsigned char k_opad[65];   /* outer padding - key XORd with opad */
  1034.   memset((char*)(auth_par_ptr), 0, 12);
  1036. #ifdef __DEBUG
  1037.   debughexcprintf(21, "key", key, 16);
  1038. #endif
  1040.   /*
  1041.    * the HMAC_SHA transform looks like:
  1042.    *
  1043.    * SHA(K XOR opad, SHA(K XOR ipad, msg))
  1044.    *
  1045.    * where K is an n byte key
  1046.    * ipad is the byte 0x36 repeated 64 times
  1047.    * opad is the byte 0x5c repeated 64 times
  1048.    * and text is the data being protected
  1049.    */
  1051.   /* start out by storing ipads and opads in pads */
  1052.   memset( (char*)k_ipad, 0x36, sizeof k_ipad);
  1053.   memset( (char*)k_opad, 0x5c, sizeof k_opad);
  1055.   /* XOR pads with key */
  1056.   for (int i=0; i < key_len; ++i) {
  1057.     k_ipad[i] ^= key[i];
  1058.     k_opad[i] ^= key[i];
  1059.   }
  1061.   /* perform inner SHA */
  1062.   SHA1_INIT(&sha_hash_state);           /* init sha_hash_state for 1st pass */
  1063.   SHA1_PROCESS(&sha_hash_state, k_ipad, 64);   /* start with inner pad      */
  1064.   SHA1_PROCESS(&sha_hash_state, msg, msg_len); /* then text of datagram     */
  1065.   SHA1_DONE(&sha_hash_state, digest);          /* finish up 1st pass        */
  1066.   /* perform outer SHA */
  1067.   SHA1_INIT(&sha_hash_state);           /* init sha_hash_state for 2nd pass */
  1068.   SHA1_PROCESS(&sha_hash_state, k_opad, 64);   /* start with outer pad      */
  1069.   SHA1_PROCESS(&sha_hash_state, digest, 20);   /* then results of 1st hash  */
  1070.   SHA1_DONE(&sha_hash_state, digest);          /* finish up 2nd pass        */
  1072. #ifdef __DEBUG
  1073.   debughexcprintf(21,"digest", digest, 160 / 8);
  1074. #endif
  1076.   memcpy(auth_par_ptr, digest, 12);
  1078.   return SNMPv3_USM_OK;
  1079. }
  1082. int AuthSHA::auth_inc_msg(const unsigned char *key,
  1083.                           unsigned char *msg,
  1084.                           const int msg_len,
  1085.                           unsigned char *auth_par_ptr,
  1086.                           const int      auth_par_len)
  1087. {
  1088.   unsigned char receivedDigest[20];
  1090.   if (auth_par_len != 12)
  1091.   {
  1092.     debugprintf(4, "SHA illegal digest length (%d), authentication FAILED.",
  1093. auth_par_len);
  1094.     return SNMPv3_USM_AUTHENTICATION_FAILURE;
  1095.   }
  1097. #ifdef __DEBUG
  1098.   debughexcprintf(21, "digest in Message", auth_par_ptr, 12);
  1099.   debughexcprintf(21, "key", key, 20);
  1100. #endif
  1102.   /* Save received digest */
  1103.   memcpy(receivedDigest, auth_par_ptr, 12);
  1105.   if (SNMPv3_USM_OK != auth_out_msg(key, msg, msg_len, auth_par_ptr))
  1106.   {
  1107.     /* copy digest back into message and return error */
  1108.     memcpy(auth_par_ptr, receivedDigest, 12);
  1109.     debugprintf(4, "SHA authentication FAILED (1).");
  1110.     return SNMPv3_USM_AUTHENTICATION_FAILURE;
  1111.   }
  1113.   /* compare digest to received digest */
  1114.   for (int i=0; i < 12 ; ++i)
  1115.   {
  1116.     if (auth_par_ptr[i] != receivedDigest[i])
  1117.     {
  1118.       /* copy digest back into message and return error */
  1119.       memcpy(auth_par_ptr, receivedDigest, 12);
  1120.       debugprintf(4, "SHA authentication FAILED.");
  1121.       return SNMPv3_USM_AUTHENTICATION_FAILURE;
  1122.     }
  1123.   }
  1124.   debugprintf(4, "SHA authentication OK.");
  1125.   return SNMPv3_USM_OK;
  1126. }
  1129. /* ----------------------- AuthMD5 ---------------------------------------*/
  1131. int AuthMD5::password_to_key(const unsigned char *password,
  1132.                              const unsigned int   password_len,
  1133.                              const unsigned char *engine_id,
  1134.                              const unsigned int   engine_id_len,
  1135.                              unsigned char *key,
  1136.                              unsigned int *key_len)
  1137. {
  1138.   *key_len = 16; /* All MD5 keys have 16 bytes length */
  1140. #ifdef __DEBUG
  1141.   debugprintf(5,"password: %s.",
  1142.               OctetStr(password, password_len).get_printable());
  1143.   debugprintf(5,"engineID: %s.",
  1144.               OctetStr(engine_id, engine_id_len).get_printable());
  1145. #endif
  1147.   MD5HashStateType md5_hash_state;
  1148.   unsigned char  *cp, password_buf[65];
  1149.   unsigned long   password_index = 0;
  1150.   unsigned long   count = 0, i;
  1152.   MD5_INIT(&md5_hash_state);   /* initialize MD5 */
  1154.   /**********************************************/
  1155.   /* Use while loop until we've done 1 Megabyte */
  1156.   /**********************************************/
  1157.   while (count < 1048576) {
  1158.     cp = password_buf;
  1159.     for (i = 0; i < 64; i++) {
  1160.       /*************************************************/
  1161.       /* Take the next octet of the password, wrapping */
  1162.       /* to the beginning of the password as necessary.*/
  1163.       /*************************************************/
  1164.       *cp++ = password[password_index++ % password_len];
  1165.     }
  1166.     MD5_PROCESS(&md5_hash_state, password_buf, 64);
  1167.     count += 64;
  1168.   }
  1169.   MD5_DONE(&md5_hash_state, key);      /* tell MD5 we're done */
  1171. #ifdef __DEBUG
  1172.   debughexcprintf(21, "key", key, *key_len);
  1173. #endif
  1175.   /*****************************************************/
  1176.   /* Now localize the key with the engine_id and pass  */
  1177.   /* through MD5 to produce final key                  */
  1178.   /* May want to ensure that engine_id_len <= 32,      */
  1179.   /* otherwise need to use a buffer larger than 64     */
  1180.   /*****************************************************/
  1181.   memcpy(password_buf,                            key,       *key_len);
  1182.   memcpy(password_buf + *key_len,                 engine_id, engine_id_len);
  1183.   memcpy(password_buf + *key_len + engine_id_len, key,       *key_len);
  1185.   MD5_INIT(&md5_hash_state);
  1186.   MD5_PROCESS(&md5_hash_state, password_buf, (2 * *key_len) + engine_id_len);
  1187.   MD5_DONE(&md5_hash_state, key);
  1189. #ifdef __DEBUG
  1190.   debughexcprintf(21, "localized key", key, *key_len);
  1191. #endif
  1193.   return SNMPv3_USM_OK;
  1194. }
  1196. int AuthMD5::hash(const unsigned char *data,
  1197.                   const unsigned int   data_len,
  1198.                   unsigned char       *digest) const
  1199. {
  1200.   MD5HashStateType md5_hash_state;
  1202.   MD5_INIT(&md5_hash_state);
  1203.   MD5_PROCESS(&md5_hash_state, data, data_len);
  1204.   MD5_DONE(&md5_hash_state, digest);
  1206.   return SNMPv3_USM_OK;
  1207. }
  1209. int AuthMD5::auth_out_msg(const unsigned char *key,
  1210.                           unsigned char *msg,
  1211.                           const int      msg_len,
  1212.                           unsigned char *auth_par_ptr)
  1213. {
  1214.   MD5HashStateType md5_hash_state;
  1215.   int           key_len = 16; /* We use only 16 Byte Key! */
  1216.   unsigned char digest[16];
  1217.   unsigned char k_ipad[65];   /* inner padding - key XORd with ipad */
  1218.   unsigned char k_opad[65];   /* outer padding - key XORd with opad */
  1220.   memset((char*)(auth_par_ptr), 0, 12);
  1222. #ifdef __DEBUG
  1223.   debughexcprintf(21, "key", key, 16);
  1224. #endif
  1226.   /*
  1227.    * the HMAC_MD5 transform looks like:
  1228.    *
  1229.    * MD5(K XOR opad, MD5(K XOR ipad, msg))
  1230.    *
  1231.    * where K is an n byte key
  1232.    * ipad is the byte 0x36 repeated 64 times
  1233.    * opad is the byte 0x5c repeated 64 times
  1234.    * and text is the data being protected
  1235.    */
  1237.   /* start out by storing key in pads */
  1238.   memset( (char*)k_ipad, 0, sizeof k_ipad);
  1239.   memset( (char*)k_opad, 0, sizeof k_opad);
  1240.   memcpy( (char*)k_ipad, (char*)key, key_len);
  1241.   memcpy( (char*)k_opad, (char*)key, key_len);
  1243.   /* XOR key with ipad and opad values */
  1244.   for (int i=0; i<64; i++) {
  1245.     k_ipad[i] ^= 0x36;
  1246.     k_opad[i] ^= 0x5c;
  1247.   }
  1249.   /* perform inner MD5 */
  1250.   MD5_INIT(&md5_hash_state);            /* init md5_hash_state for 1st pass */
  1251.   MD5_PROCESS(&md5_hash_state, k_ipad, 64);    /* start with inner pad      */
  1252.   MD5_PROCESS(&md5_hash_state, msg, msg_len);  /* then text of datagram     */
  1253.   MD5_DONE(&md5_hash_state, digest);           /* finish up 1st pass        */
  1254.   /* perform outer MD5 */
  1255.   MD5_INIT(&md5_hash_state);            /* init md5_hash_state for 2nd pass */
  1256.   MD5_PROCESS(&md5_hash_state, k_opad, 64);    /* start with outer pad      */
  1257.   MD5_PROCESS(&md5_hash_state, digest, 16);    /* then results of 1st hash  */
  1258.   MD5_DONE(&md5_hash_state, digest);           /* finish up 2nd pass        */
  1260. #ifdef __DEBUG
  1261.   debughexcprintf(21, "digest", digest, 128 / 8);
  1262. #endif
  1264.   memcpy(auth_par_ptr, digest, 12);
  1266.   return SNMPv3_USM_OK;
  1267. }
  1269. int AuthMD5::auth_inc_msg(const unsigned char *key,
  1270.                           unsigned char *msg,
  1271.                           const int msg_len,
  1272.                           unsigned char *auth_par_ptr,
  1273.                           const int      auth_par_len)
  1274. {
  1275.   unsigned char receivedDigest[16];
  1277.   if (auth_par_len != 12)
  1278.   {
  1279.     debugprintf(4, "MD5 illegal digest length (%d), authentication FAILED.",
  1280. auth_par_len);
  1281.     return SNMPv3_USM_AUTHENTICATION_FAILURE;
  1282.   }
  1284. #ifdef __DEBUG
  1285.   debughexcprintf(21, "digest in Message", auth_par_ptr, 12);
  1286.   debughexcprintf(21, "key", key, 16);
  1287. #endif
  1289.   memcpy(receivedDigest, auth_par_ptr, 12);
  1291.   if (SNMPv3_USM_OK != auth_out_msg(key, msg, msg_len, auth_par_ptr))
  1292.   {
  1293.     /* copy digest back into message and return error */
  1294.     memcpy(auth_par_ptr, receivedDigest, 12);
  1295.     debugprintf(4, "MD5 authentication FAILED (1).");
  1296.     return SNMPv3_USM_AUTHENTICATION_FAILURE;
  1297.   }
  1299.   /* compare digest to received digest */
  1300.   for (int i=0; i < 12 ; ++i)
  1301.   {
  1302.     if (auth_par_ptr[i] != receivedDigest[i])
  1303.     {
  1304.       /* copy digest back into message and return error */
  1305.       memcpy(auth_par_ptr, receivedDigest, 12);
  1306.       debugprintf(4, "MD5 authentication FAILED.");
  1307.       return SNMPv3_USM_AUTHENTICATION_FAILURE;
  1308.     }
  1309.   }
  1310.   debugprintf(4, "MD5 authentication OK.");
  1311.   return SNMPv3_USM_OK;
  1312. }
  1314. /* ========================= PRIV ================================*/
  1316. /* ----------------------- PrivDES ---------------------------------------*/
  1318. #if defined(_USE_LIBTOMCRYPT) && !defined(_USE_OPENSSL)
  1319. PrivDES::PrivDES()
  1320. {
  1321.   cipher = find_cipher("des");
  1322. }
  1323. #endif
  1325. int PrivDES::encrypt(const unsigned char *key,
  1326.                      const unsigned int   /*key_len*/,
  1327.                      const unsigned char *buffer,
  1328.                      const unsigned int   buffer_len,
  1329.                      unsigned char       *out_buffer,
  1330.                      unsigned int        *out_buffer_len,
  1331.                      unsigned char       *privacy_params,
  1332.                      unsigned int        *privacy_params_len,
  1333.                      const unsigned long  engine_boots,
  1334.                      const unsigned long  /*engine_time*/)
  1335. {
  1336.   unsigned char initVect[8];
  1337.   pp_uint64     my_salt = (*salt)++;
  1339. #ifdef INVALID_ENCRYPTION
  1340.   debugprintf(-10, "nWARNING: Encrypting with zeroed salt!n");
  1341.   my_salt = 0;
  1342. #endif
  1344.   /* check space in privacy_params buffer */
  1345.   if (*privacy_params_len < 8)
  1346.   {
  1347.     debugprintf(4, "Buffer too small: should be 8, is (%i).",
  1348.                 *privacy_params_len);
  1349.     return SNMPv3_USM_ENCRYPTION_ERROR;
  1350.   }
  1351.   /* Length is always 8 */
  1352.   *privacy_params_len = 8;
  1354.   // last 8 bytes of key are used as base for initialization vector
  1355.   memcpy((char*)initVect, key+8, 8);
  1357.   // put salt in privacy_params
  1358.   for (int j=0; j<4; j++)
  1359.   {
  1360.     privacy_params[3-j] = (unsigned char) (0xFF & (engine_boots >> (8*j)));
  1361.     privacy_params[7-j] = (unsigned char) (0xFF & (my_salt >> (8*j)));
  1362.   }
  1364.   // xor initVect with salt
  1365.   for (int i=0; i<8; i++)
  1366.     initVect[i] ^= privacy_params[i];
  1368. #ifdef __DEBUG
  1369.   debughexcprintf(21, "apDESEncryptData: Data to encrypt",
  1370.                  buffer, buffer_len);
  1371.   debughexcprintf(21, "apDESEncryptData: used key (only 8 bytes used)",
  1372.                   key, 16);
  1373.   debughexcprintf(21, "apDESEncryptData: used iv",
  1374.                   initVect, 8);
  1375. #endif
  1377.   DESCBCType symcbc;
  1378.   DES_CBC_START_ENCRYPT(cipher, initVect, key, 8, 16, symcbc);
  1380.   for(unsigned int k = 0; k <= buffer_len - 8; k += 8) {
  1381.     DES_CBC_ENCRYPT(buffer + k, out_buffer + k, symcbc, initVect, 8);
  1382.   }
  1384.   /* last part of buffer */
  1385.   if (buffer_len % 8)
  1386.   {
  1387.     unsigned char tmp_buf[8];
  1388.     unsigned char *tmp_buf_ptr = tmp_buf;
  1389.     int start = buffer_len - (buffer_len % 8);
  1390.     memset(tmp_buf, 0, 8);
  1391.     for (unsigned int l = start; l < buffer_len; l++)
  1392.       *tmp_buf_ptr++ = buffer[l];
  1393.     DES_CBC_ENCRYPT(tmp_buf, out_buffer + start, symcbc, initVect, 8);
  1394.     *out_buffer_len = buffer_len + 8 - (buffer_len % 8);
  1395.   }
  1396.   else
  1397.     *out_buffer_len = buffer_len;
  1399.   /* Clear context buffer (paranoia!)*/
  1400.   DES_MEMSET(symcbc, 0, sizeof(symcbc));
  1402. #ifdef __DEBUG
  1403.   debughexcprintf(21, "apDESEncryptData: created privacy_params",
  1404.                   privacy_params, 8);
  1405.   debughexcprintf(21, "apDESEncryptData: encrypted Data",
  1406.                   out_buffer, *out_buffer_len);
  1407. #endif
  1409.   return SNMPv3_USM_OK;
  1410. }
  1414. int PrivDES::decrypt(const unsigned char *key,
  1415.                      const unsigned int   /*key_len*/,
  1416.                      const unsigned char *buffer,
  1417.                      const unsigned int   buffer_len,
  1418.                      unsigned char *outBuffer,
  1419.                      unsigned int  *outBuffer_len,
  1420.                      const unsigned char *privacy_params,
  1421.                      const unsigned int   privacy_params_len,
  1422.      const unsigned long  /*engine_boots*/,
  1423.      const unsigned long  /*engine_time*/)
  1424. {
  1425.   unsigned char initVect[8];
  1427.   /* Privacy params length has to be 8  && Length has to be a multiple of 8 */
  1428.   if (( buffer_len % 8 ) || (privacy_params_len != 8))
  1429.     return SNMPv3_USM_DECRYPTION_ERROR;
  1431.   for (int i=0; i<8; i++)
  1432.     initVect[i] = privacy_params[i] ^ key[i+8];
  1434.   memset((char*)outBuffer, 0, *outBuffer_len);
  1436. #ifdef __DEBUG
  1437.   debughexcprintf(21, "apDESDecryptData: Data to decrypt",
  1438.                   buffer, buffer_len);
  1439.   debughexcprintf(21, "apDESDecryptData: used key (only 8 bytes used)",
  1440.                   key, 16);
  1441.   debughexcprintf(21, "apDESDecryptData: used privacy_params",
  1442.                   privacy_params, 8);
  1443.   debughexcprintf(21, "apDESDecryptData: used iv",
  1444.                   initVect, 8);
  1445. #endif
  1447.   DESCBCType symcbc;
  1448.   DES_CBC_START_DECRYPT(cipher, initVect, key, 8, 16, symcbc);
  1449.   for(unsigned int j=0; j<buffer_len; j+=8 ) {
  1450.     DES_CBC_DECRYPT(buffer + j, outBuffer + j, symcbc, initVect, 8);
  1451.   }
  1452.   /* Clear context (paranoia!) */
  1453.   DES_MEMSET(symcbc, 0, sizeof(symcbc));
  1455.   *outBuffer_len = buffer_len;
  1457. #ifdef __DEBUG
  1458.   debughexcprintf(21, "apDESDecryptData: decrypted Data",
  1459.                   outBuffer, *outBuffer_len);
  1460. #endif
  1462.   return SNMPv3_USM_OK;
  1463. }
  1466. /* ----------------------- PrivIDEA --------------------------------------*/
  1468. #ifdef _USE_IDEA
  1470. int PrivIDEA::encrypt(const unsigned char *key,
  1471.                       const unsigned int   /*key_len*/,
  1472.                       const unsigned char *buffer,
  1473.                       const unsigned int   buffer_len,
  1474.                       unsigned char       *out_buffer,
  1475.                       unsigned int        *out_buffer_len,
  1476.                       unsigned char       *privacy_params,
  1477.                       unsigned int        *privacy_params_len,
  1478.                       const unsigned long  engine_boots,
  1479.                       const unsigned long  /*engine_time*/)
  1480. {
  1481.   IDEAContext CFB_Context;
  1482.   pp_uint64 my_salt = (*salt)++;
  1484. #ifdef INVALID_ENCRYPTION
  1485.   debugprintf(-10, "nWARNING: Encrypting with zeroed salt!n");
  1486.   my_salt = 0;
  1487. #endif
  1489.   /* check space in privacy_params buffer */
  1490.   if (*privacy_params_len < 8)
  1491.   {
  1492.     debugprintf(4, "Buffer too small: should be 8, is (%i).", *privacy_params_len);
  1493.     return SNMPv3_USM_ENCRYPTION_ERROR;
  1494.   }
  1495.   /* Length is always 8 */
  1496.   *privacy_params_len = 8;
  1498.   // last 8 bytes of key are used as base for initialization vector
  1499.   unsigned char iv[8];
  1501.   memcpy((char*)iv, key+8, 8);
  1503.   // put salt in privacy_params
  1504.   for (int j=0; j<4; j++)
  1505.   {
  1506.     privacy_params[3-j] = (unsigned char) (0xFF & (engine_boots >> (8*j)));
  1507.     privacy_params[7-j] = (unsigned char) (0xFF & (my_salt >> (8*j)));
  1508.   }
  1509.   // xor iv with privacy_params
  1510.   for (int i=0; i<8; i++)
  1511.     iv[i] ^= privacy_params[i];
  1513.   idea_set_key(&CFB_Context, key);
  1515.   idea_cfb_encrypt(&CFB_Context, iv, out_buffer,
  1516.                    buffer, buffer_len);
  1518.   /* Clear context (paranoia!) */
  1519.   idea_destroy_context(&CFB_Context);
  1521.   *out_buffer_len = buffer_len;
  1523. #ifdef __DEBUG
  1524.   debughexcprintf(21, "apIDEAEncryptData: Data to encrypt",
  1525.                   buffer, buffer_len);
  1526.   debughexcprintf(21, "apIDEAEncryptData: key",
  1527.                   key, 16);
  1528.   debughexcprintf(21, "apIDEAEncryptData: privacy_params",
  1529.                   privacy_params, 8);
  1530.   debughexcprintf(21, "apIDEAEncryptData: encrypted Data",
  1531.                   out_buffer, *out_buffer_len);
  1532. #endif
  1534.   return SNMPv3_USM_OK;
  1535. }
  1537. int PrivIDEA::decrypt(const unsigned char *key,
  1538.                       const unsigned int   /*key_len*/,
  1539.                       const unsigned char *buffer,
  1540.                       const unsigned int   buffer_len,
  1541.                       unsigned char *out_buffer,
  1542.                       unsigned int  *out_buffer_len,
  1543.                       const unsigned char *privacy_params,
  1544.                       const unsigned int   privacy_params_len,
  1545.       const unsigned long  /*engine_boots*/,
  1546.       const unsigned long  /*engine_time*/)
  1547. {
  1548.   unsigned char iv[8];
  1549.   IDEAContext CFB_Context;
  1551.   /* privacy params length has to be 8 */
  1552.   if (privacy_params_len != 8)
  1553.     return SNMPv3_USM_DECRYPTION_ERROR;
  1555.   idea_set_key(&CFB_Context, key);
  1557.   memset((char*)out_buffer, 0, *out_buffer_len);
  1559.   /* Initialize iv with last 8 bytes of key and xor with privacy_params */
  1560.   memcpy((char*)iv, key+8, 8);
  1561.   for (int i=0; i<8; i++)
  1562.     iv[i] ^= privacy_params[i];
  1564.   idea_cfb_decrypt(&CFB_Context, iv, out_buffer,
  1565.                    buffer, buffer_len);
  1567.   /* Clear context (paranoia!) */
  1568.   idea_destroy_context(&CFB_Context);
  1569.   memset((char*)iv, 0, 8);
  1571.   *out_buffer_len = buffer_len;
  1573. #ifdef __DEBUG
  1574.   debughexcprintf(21, "apIDEADecryptData: Data to decrypt",
  1575.                   buffer, buffer_len);
  1576.   debughexcprintf(21, "apIDEADecryptData: key", key, 16);
  1577.   debughexcprintf(21, "apIDEAEncryptData: privacy_params", privacy_params, 8);
  1578.   debughexcprintf(21, "apIDEADecryptData: decrypted Data",
  1579.                   out_buffer, *out_buffer_len);
  1580. #endif
  1582.   return SNMPv3_USM_OK;
  1583. }
  1585. #endif // _USE_IDEA
  1587. #if defined(_USE_LIBTOMCRYPT) || defined(_USE_OPENSSL)
  1589. PrivAES::PrivAES(const int aes_type_)
  1590.   : aes_type(aes_type_)
  1591. {
  1592. #if defined(_USE_LIBTOMCRYPT) && !defined(_USE_OPENSSL)
  1593.   cipher = find_cipher("rijndael");
  1594. #endif
  1596.   switch (aes_type)
  1597.   {
  1598.     case SNMP_PRIVPROTOCOL_AES128:
  1599.       key_bytes = 16;
  1600.       rounds = 10;
  1601.       break;
  1602.     case SNMP_PRIVPROTOCOL_AES192:
  1603.       key_bytes = 24;
  1604.       rounds = 12;
  1605.       break;
  1606.     case SNMP_PRIVPROTOCOL_AES256:
  1607.       key_bytes = 32;
  1608.       rounds = 14;
  1609.       break;
  1610.     default:
  1611.       debugprintf(0, "Wrong AES type: %i.", aes_type);
  1612.       key_bytes = 0;
  1613.       rounds = 0;
  1614.       aes_type = -1; // will cause an error in AuthPriv::add_priv()
  1615.   }
  1617.   unsigned int testswap = htonl(0x01020304);
  1618.   if (testswap == 0x01020304)
  1619.     need_byteswap = FALSE;
  1620.   else
  1621.     need_byteswap = TRUE;
  1622. }
  1624. const char *PrivAES::get_id_string() const
  1625. {
  1626.   switch (aes_type)
  1627.   {
  1628.     case SNMP_PRIVPROTOCOL_AES128: return "AES128";  break;
  1629.     case SNMP_PRIVPROTOCOL_AES192: return "AES192";  break;
  1630.     case SNMP_PRIVPROTOCOL_AES256: return "AES256";  break;
  1631.     default:                       return "error";   break;
  1632.   }
  1633. };
  1635. int PrivAES::encrypt(const unsigned char *key,
  1636.      const unsigned int   key_len,
  1637.      const unsigned char *buffer,
  1638.      const unsigned int   buffer_len,
  1639.      unsigned char       *out_buffer,
  1640.      unsigned int        *out_buffer_len,
  1641.      unsigned char       *privacy_params,
  1642.      unsigned int        *privacy_params_len,
  1643.      const unsigned long  engine_boots,
  1644.      const unsigned long  engine_time)
  1645. {
  1646.   unsigned char initVect[16];
  1647.   pp_uint64 my_salt = (*salt)++;
  1649. #ifdef INVALID_ENCRYPTION
  1650.   debugprintf(-10, "nWARNING: Encrypting with zeroed salt!n");
  1651.   my_salt = 0;
  1652. #endif
  1654.   /* check space in privacy_params buffer */
  1655.   if (*privacy_params_len < 8)
  1656.   {
  1657.     debugprintf(4, "Buffer too small: should be 8, is (%i).",
  1658.                 *privacy_params_len);
  1659.     return SNMPv3_USM_ENCRYPTION_ERROR;
  1660.   }
  1661.   /* Length is always 8 */
  1662.   *privacy_params_len = 8;
  1664.   /* Set IV as engine_boots + engine_time + salt */
  1665.   unsigned int *tmpi = (unsigned int *)initVect;
  1666.   *tmpi++ = htonl(engine_boots);
  1667.   *tmpi++ = htonl(engine_time);
  1668.   if (need_byteswap)
  1669.   {
  1670.     *tmpi++ = htonl(my_salt & 0xFFFFFFFF);
  1671.     *tmpi   = htonl((my_salt >> 32) & 0xFFFFFFFF);
  1672.   }
  1673.   else
  1674.     memcpy(tmpi, &my_salt, 8);
  1676.   /* put byteswapped salt in privacy_params */
  1677.   memcpy(privacy_params, initVect + 8, 8);
  1678.   debughexcprintf(21, "aes initVect:", initVect, 16);
  1680. #ifdef _USE_OPENSSL
  1681.   AES_KEY symcfb;
  1682.   int dummy = 0;
  1684.   if (AES_set_encrypt_key(key, key_len * 8, &symcfb) < 0)
  1685.   {
  1686.     
  1687.     debugprintf(1, "AES_set_encrypt_key(%p, %d, %p) failed.",
  1688. key, key_len * 8, &symcfb);
  1689.     return SNMPv3_USM_ERROR;
  1690.   }
  1692.   AES_cfb128_encrypt(buffer, out_buffer, buffer_len,
  1693.      &symcfb, initVect, &dummy, AES_ENCRYPT);
  1694. #else
  1695.   symmetric_CFB symcfb;
  1697.   cfb_start(cipher, initVect, key, key_bytes, rounds, &symcfb);
  1698.   cfb_encrypt((unsigned char*)buffer, out_buffer, buffer_len, &symcfb);
  1699. #endif
  1701.   /* Clear context and plaintext buffer (paranoia!)*/
  1702.   memset(&symcfb, 0, sizeof(symcfb));
  1704.   *out_buffer_len = buffer_len;
  1706. #ifdef __DEBUG
  1707.   debughexcprintf(21, "aes EncryptData: Data to encrypt", buffer, buffer_len);
  1708.   debughexcprintf(21, "aes EncryptData: used key", key, key_len);
  1709.   debughexcprintf(21, "aes EncryptData: created privacy_params",
  1710.                   privacy_params, 8);
  1711.   debughexcprintf(21, "aes EncryptData: encrypted Data",
  1712.                   out_buffer, *out_buffer_len);
  1713. #endif
  1715.   return SNMPv3_USM_OK;
  1716. }
  1718. int PrivAES::decrypt(const unsigned char *key,
  1719.      const unsigned int   key_len,
  1720.      const unsigned char *buffer,
  1721.      const unsigned int   buffer_len,
  1722.      unsigned char       *out_buffer,
  1723.      unsigned int        *out_buffer_len,
  1724.      const unsigned char *privacy_params,
  1725.      const unsigned int   privacy_params_len,
  1726.      const unsigned long  engine_boots,
  1727.      const unsigned long  engine_time)
  1728. {
  1729.   unsigned char initVect[16];
  1731.   /* Privacy params length has to be 8 */
  1732.   if (privacy_params_len != 8)
  1733.     return SNMPv3_USM_DECRYPTION_ERROR;
  1735.   /* build IV */
  1736.   unsigned int *tmp;
  1737.   tmp = (unsigned int *)initVect;
  1738.   *tmp++ = htonl(engine_boots);
  1739.   *tmp = htonl(engine_time);
  1740.   memcpy(initVect + 8, privacy_params, 8);
  1741.   debughexcprintf(21, "aes initVect:", initVect, 16);
  1743. #ifdef _USE_OPENSSL
  1744.   int dummy = 0;
  1745.   AES_KEY symcfb;
  1747.   AES_set_encrypt_key(key, key_len * 8, &symcfb);
  1748.   AES_cfb128_encrypt(buffer, out_buffer, buffer_len,
  1749.      &symcfb, initVect, &dummy, AES_DECRYPT);
  1750. #else
  1751.   symmetric_CFB symcfb;
  1753.   cfb_start(cipher, initVect, key, key_bytes, rounds, &symcfb);
  1754.   cfb_decrypt((unsigned char*)buffer, out_buffer, buffer_len, &symcfb);
  1755. #endif
  1757.   /* Clear context and plaintext buffer (paranoia!)*/
  1758.   memset(&symcfb, 0, sizeof(symcfb));
  1760.   *out_buffer_len = buffer_len;
  1762. #ifdef __DEBUG
  1763.   debughexcprintf(21, "aes DecryptData: Data to decrypt", buffer, buffer_len);
  1764.   debughexcprintf(21, "aes DecryptData: used key", key, key_len);
  1765.   debughexcprintf(21, "aes DecryptData: used privacy_params",
  1766.                   privacy_params, 8);
  1767.   debughexcprintf(21, "aes DecryptData: decrypted Data",
  1768.                   out_buffer, *out_buffer_len);
  1769. #endif
  1771.   return SNMPv3_USM_OK;
  1772. }
  1774. int PrivAES::extend_short_key(const unsigned char *password,
  1775.                               const unsigned int   password_len,
  1776.                               const unsigned char *engine_id,
  1777.                               const unsigned int   engine_id_len,
  1778.                               unsigned char       *key,
  1779.                               unsigned int        *key_len,
  1780.                               const unsigned int   max_key_len,
  1781.                               Auth                *auth)
  1782. {
  1783.   if (max_key_len < (unsigned)key_bytes)
  1784.       return SNMPv3_USM_ERROR;
  1786.   int res = 0;
  1787.   unsigned char *hash_buf = new unsigned char[auth->get_hash_len()];
  1789.   if (!hash_buf)
  1790.   {
  1791.     debugprintf(0, "Out of mem. Did not get %i bytes.", auth->get_hash_len());
  1792.     return SNMPv3_USM_ERROR;
  1793.   }
  1795.   while (*key_len < (unsigned)key_bytes)
  1796.   {
  1797.     res = auth->hash(key, *key_len, hash_buf);
  1798.     if (res != SNMPv3_USM_OK)
  1799.       break;
  1801.     int copy_bytes = key_bytes - *key_len;
  1802.     if (copy_bytes > auth->get_hash_len())
  1803.       copy_bytes = auth->get_hash_len();
  1804.     if (*key_len + copy_bytes > max_key_len)
  1805. copy_bytes = max_key_len - *key_len;
  1806.     memcpy(key + *key_len, hash_buf, copy_bytes);
  1807.     *key_len += copy_bytes;
  1808.   }
  1810.   if (hash_buf) delete [] hash_buf;
  1812.   return res;
  1813. }
  1816. #endif // _USE_LIBTOMCRYPT or _USE_OPENSSL
  1819. #ifdef _USE_3DES_EDE
  1821. #if defined(_USE_LIBTOMCRYPT) && !defined(_USE_OPENSSL)
  1822. Priv3DES_EDE::Priv3DES_EDE()
  1823. {
  1824.   cipher = find_cipher("3des");
  1825.   debugprintf(10, "tomcrypt returned cipher %d", cipher);
  1826. }
  1827. #endif
  1830. int 
  1831. Priv3DES_EDE::encrypt(const unsigned char *key,
  1832.       const unsigned int   key_len,
  1833.       const unsigned char *buffer,
  1834.       const unsigned int   buffer_len,
  1835.       unsigned char       *out_buffer,
  1836.       unsigned int        *out_buffer_len,
  1837.       unsigned char       *privacy_params,
  1838.       unsigned int        *privacy_params_len,
  1839.       const unsigned long  engine_boots,
  1840.       const unsigned long  engine_time)
  1841. {
  1842.   unsigned char initVect[8];
  1843.   pp_uint64     my_salt = (*salt)++;
  1844.   
  1845. #ifdef INVALID_ENCRYPTION
  1846.   debugprintf(-10, "nWARNING: Encrypting with zeroed salt!n");
  1847.   my_salt = 0;
  1848. #endif
  1850.   /* check space in privacy_params buffer */
  1851.   if (*privacy_params_len < 8)
  1852.   {
  1853.     debugprintf(4, "Buffer too small: should be 8, is (%i).",
  1854.                 *privacy_params_len);
  1855.     return SNMPv3_USM_ENCRYPTION_ERROR;
  1856.   }
  1857.   /* Length is always 8 */
  1858.   *privacy_params_len = 8;
  1860.   /* check key length */
  1861.   if (key_len < TRIPLEDES_EDE_KEY_LEN)
  1862.   {
  1863.     debugprintf(4, "Key too small: should be %d, is (%d).",
  1864.                 TRIPLEDES_EDE_KEY_LEN, key_len);
  1865.     return SNMPv3_USM_ENCRYPTION_ERROR;
  1866.   }
  1868.   /* TODO: check if K1 != K2 != K3 */
  1870.   // last 8 bytes of key are used as base for initialization vector
  1871.   memcpy((char*)initVect, key+24, 8);
  1873.   /* TODO: generate salt as specified in draft */
  1875.   // put salt in privacy_params
  1876.   for (int j=0; j<4; j++)
  1877.   {
  1878.     privacy_params[3-j] = (unsigned char) (0xFF & (engine_boots >> (8*j)));
  1879.     privacy_params[7-j] = (unsigned char) (0xFF & (my_salt >> (8*j)));
  1880.   }
  1882.   // xor initVect with salt
  1883.   for (int i=0; i<8; i++)
  1884.     initVect[i] ^= privacy_params[i];
  1887. #ifdef __DEBUG
  1888.   debughexcprintf(21, "3DES Data to encrypt", buffer, buffer_len);
  1889.   debughexcprintf(21, "3DES used iv", initVect, 8);
  1890.   debughexcprintf(21, "3DES key", key, key_len);
  1891. #endif
  1893.   // The first 24 octets of the 32-octet secret are used as a 3DES-EDE
  1894.   // key. Since 3DES-EDE uses only 168 bits the least significant bit
  1895.   // in each octet is disregarded
  1897. #if defined(_USE_LIBTOMCRYPT) && !defined(_USE_OPENSSL)
  1898.   DESCBCType symcbc;
  1899.   DES_CBC_START_ENCRYPT(cipher, initVect, key, 24, 16, symcbc);
  1901.   for(unsigned int k = 0; k <= buffer_len - 8; k += 8) {
  1902.     DES_CBC_ENCRYPT(buffer + k, out_buffer + k, symcbc, initVect, 8);
  1903.   }
  1905.   /* last part of buffer */
  1906.   if (buffer_len % 8)
  1907.   {
  1908.     unsigned char tmp_buf[8];
  1909.     unsigned char *tmp_buf_ptr = tmp_buf;
  1910.     int start = buffer_len - (buffer_len % 8);
  1911.     memset(tmp_buf, 0, 8);
  1912.     for (unsigned int l = start; l < buffer_len; l++)
  1913.       *tmp_buf_ptr++ = buffer[l];
  1914.     DES_CBC_ENCRYPT(tmp_buf, out_buffer + start, symcbc, initVect, 8);
  1915.     *out_buffer_len = buffer_len + 8 - (buffer_len % 8);
  1916.   }
  1917.   else
  1918.     *out_buffer_len = buffer_len;
  1920.   /* Clear context buffer (paranoia!)*/
  1921.   DES_MEMSET(symcbc, 0, sizeof(symcbc));
  1923. #else
  1924.   DESCBCType ks1, ks2, ks3;
  1926.   if ((des_key_sched((C_Block*)(key),     ks1) < 0) ||
  1927.       (des_key_sched((C_Block*)(key +8),  ks2) < 0) ||
  1928.       (des_key_sched((C_Block*)(key +16), ks3) < 0))
  1929.   {
  1930.       debugprintf(0, "Starting 3DES-EDE encryption failed.");
  1931.       return SNMPv3_USM_ERROR;
  1932.   }
  1934.   if (buffer_len >= 8)
  1935.     for(unsigned int k = 0; k <= (buffer_len - 8); k += 8) 
  1936.     {
  1937.       DES_EDE3_CBC_ENCRYPT(buffer+k, out_buffer+k, 8,
  1938.    ks1, ks2, ks3, initVect);
  1939.     }
  1941.   // Last part
  1942.   if (buffer_len % 8)
  1943.     {
  1944.       unsigned char tmp_buf[8];
  1945.       unsigned char *tmp_buf_ptr = tmp_buf;
  1946.       int start = buffer_len - (buffer_len % 8);
  1947.       memset(tmp_buf, 0, 8);
  1948.       for (unsigned int l = start; l < buffer_len; l++)
  1949. *tmp_buf_ptr++ = buffer[l];
  1950.       DES_EDE3_CBC_ENCRYPT(tmp_buf, out_buffer + start, 8,
  1951.    ks1, ks2, ks3, initVect);
  1952.       
  1953.       *out_buffer_len = buffer_len + 8 - (buffer_len % 8);
  1954.     }
  1955.   else
  1956.     *out_buffer_len = buffer_len;
  1958.   /* Clear context buffer (paranoia!)*/
  1959.   DES_MEMSET(ks1, 0, sizeof(ks1));
  1960.   DES_MEMSET(ks2, 0, sizeof(ks2));
  1961.   DES_MEMSET(ks3, 0, sizeof(ks3));
  1962. #endif
  1964. #ifdef __DEBUG
  1965.   debughexcprintf(21, "3DES created privacy_params", privacy_params, 8);
  1966.   debughexcprintf(21, "3DES encrypted Data", out_buffer, *out_buffer_len);
  1967. #endif
  1969.   return SNMPv3_USM_OK;
  1970. }
  1973. int 
  1974. Priv3DES_EDE::decrypt(const unsigned char *key,
  1975.       const unsigned int   key_len,
  1976.       const unsigned char *buffer,
  1977.       const unsigned int   buffer_len,
  1978.       unsigned char       *out_buffer,
  1979.       unsigned int        *out_buffer_len,
  1980.       const unsigned char *privacy_params,
  1981.       const unsigned int   privacy_params_len,
  1982.       const unsigned long  engine_boots,
  1983.       const unsigned long  engine_time)
  1984. {
  1985.   unsigned char initVect[8];
  1987.   /* Privacy params length has to be 8  && Length has to be a multiple of 8 */
  1988.   if (( buffer_len % 8 ) || (privacy_params_len != 8))
  1989.     return SNMPv3_USM_DECRYPTION_ERROR;
  1991.   for (int i=0; i<8; i++)
  1992.     initVect[i] = privacy_params[i] ^ key[i+24];
  1994.   memset((char*)out_buffer, 0, *out_buffer_len);
  1996. #ifdef __DEBUG
  1997.   debughexcprintf(21, "3DES Data to decrypt", buffer, buffer_len);
  1998.   debughexcprintf(21, "3DES privacy_params",  privacy_params, 8);
  1999.   debughexcprintf(21, "3DES used iv",   initVect, 8);
  2000.   debughexcprintf(21, "3DES key", key, key_len);
  2001. #endif
  2003. #if defined(_USE_LIBTOMCRYPT) && !defined(_USE_OPENSSL)
  2004.   DESCBCType symcbc;
  2005.   DES_CBC_START_DECRYPT(cipher, initVect, key, 24, 16, symcbc);
  2006.   for(unsigned int j=0; j<buffer_len; j+=8 ) {
  2007.     DES_CBC_DECRYPT(buffer + j, out_buffer + j, symcbc, initVect, 8);
  2008.   }
  2009.   /* Clear context (paranoia!) */
  2010.   DES_MEMSET(symcbc, 0, sizeof(symcbc));
  2012. #else
  2013.   DESCBCType ks1, ks2, ks3;
  2015.   if ((des_key_sched((C_Block*)(key),     ks1) < 0) ||
  2016.       (des_key_sched((C_Block*)(key+8),  ks2) < 0) ||
  2017.       (des_key_sched((C_Block*)(key+16), ks3) < 0))
  2018.     {
  2019.       debugprintf(0, "Starting 3DES-EDE decryption failed.");
  2020.       return SNMPv3_USM_ERROR;
  2021.     }
  2023.   for(unsigned int k=0; k<buffer_len; k+=8 ) 
  2024.     {
  2025.       DES_EDE3_CBC_DECRYPT(buffer+k, out_buffer+k, 8,
  2026.    ks1, ks2, ks3, initVect);
  2027.     }
  2028.   /* Clear context (paranoia!) */
  2029.   DES_MEMSET(ks1, 0, sizeof(ks1));
  2030.   DES_MEMSET(ks2, 0, sizeof(ks2));
  2031.   DES_MEMSET(ks3, 0, sizeof(ks3));
  2032. #endif
  2034.   *out_buffer_len = buffer_len;
  2036. #ifdef __DEBUG
  2037.   debughexcprintf(21, "3DES decrypted Data", out_buffer, *out_buffer_len);
  2038. #endif
  2040.   return SNMPv3_USM_OK;  
  2041. }
  2044. int 
  2045. Priv3DES_EDE::extend_short_key(const unsigned char *password,
  2046.        const unsigned int   password_len,
  2047.        const unsigned char *engine_id,
  2048.        const unsigned int   engine_id_len,
  2049.        unsigned char       *key,
  2050.        unsigned int        *key_len,
  2051.        const unsigned int   max_key_len,
  2052.        Auth                *auth)
  2053. {
  2054.   if (max_key_len < TRIPLEDES_EDE_KEY_LEN)
  2055.     return SNMPv3_USM_ERROR;
  2057.   unsigned int p2k_output_len = *key_len;
  2058.   unsigned char *p2k_buf = new unsigned char[p2k_output_len];
  2059.   int res = 0;
  2061.   if (!p2k_buf) return SNMPv3_USM_ERROR;
  2063.   while (*key_len < TRIPLEDES_EDE_KEY_LEN)
  2064.   {
  2065.     unsigned int p2k_buf_len = p2k_output_len;
  2067.     res = auth->password_to_key(key, *key_len,
  2068. engine_id, engine_id_len,
  2069. p2k_buf, &p2k_buf_len);
  2071.     if (res != SNMPv3_USM_OK)
  2072.       break;
  2074.     unsigned int copy_bytes = TRIPLEDES_EDE_KEY_LEN - *key_len;
  2076.     if (copy_bytes > p2k_buf_len)
  2077. copy_bytes = p2k_buf_len;
  2079.     if (*key_len + copy_bytes > max_key_len)
  2080. copy_bytes = max_key_len - *key_len;
  2082.     memcpy(key + *key_len, p2k_buf, copy_bytes);
  2084.     *key_len += copy_bytes;
  2085.   }
  2087.   if (p2k_buf) delete [] p2k_buf;
  2089.   return res;
  2090. }
  2092. #ifdef _TEST
  2093. bool Priv3DES_EDE::test()
  2094. {
  2095.   int status;
  2096.   AuthPriv ap(status);
  2097.   if (status != SNMPv3_USM_OK)
  2098.       return false;
  2100.   if (ap.add_auth(new AuthSHA()) != SNMP_ERROR_SUCCESS)
  2101.   {
  2102.       debugprintf(0, "Error: could not add AuthSHA.");
  2103.       return false;
  2104.   }
  2106.   if (ap.add_auth(new AuthMD5()) != SNMP_ERROR_SUCCESS)
  2107.   {
  2108.       debugprintf(0, "Error: could not add AuthMD5.");
  2109.       return false;
  2110.   }
  2112.   if (ap.add_priv(new Priv3DES_EDE()) != SNMP_ERROR_SUCCESS)
  2113.   {
  2114.       debugprintf(0, "Error: could not add Priv3DES_EDE.");
  2115.       return false;
  2116.   }
  2118.   unsigned char password[11] = "maplesyrup";
  2119.   unsigned char engine_id[12];
  2121.   memset(engine_id, 0, 11);
  2122.   engine_id[11] = 2;
  2124.   unsigned char key[TRIPLEDES_EDE_KEY_LEN];
  2125.   unsigned int key_len = TRIPLEDES_EDE_KEY_LEN;
  2127.   status = ap.password_to_key_priv(SNMP_AUTHPROTOCOL_HMACSHA,
  2128.                                    SNMP_PRIVPROTOCOL_3DESEDE,
  2129.                                    password, 10,
  2130.                                    engine_id, 12,
  2131.                                    key,  &key_len);
  2133.   debughexcprintf(1, "result key 3DES SHA",
  2134.                   key, key_len);
  2136.   key_len = TRIPLEDES_EDE_KEY_LEN;
  2137.   status = ap.password_to_key_priv(SNMP_AUTHPROTOCOL_HMACMD5,
  2138.                                    SNMP_PRIVPROTOCOL_3DESEDE,
  2139.                                    password, 10,
  2140.                                    engine_id, 12,
  2141.                                    key,  &key_len);
  2143.   debughexcprintf(1, "result key 3DES MD5",
  2144.                   key, key_len);
  2146.   unsigned char msg[80] = "This is the secret message, that has to be encrypted!";
  2147.   unsigned char enc_buffer[80];
  2148.   unsigned int enc_buffer_len = 80;
  2149.   unsigned char dec_buffer[80];
  2150.   unsigned int dec_buffer_len = 80;
  2151.   unsigned char priv_params[64];
  2152.   unsigned int priv_params_len = 64;
  2155.   status = ap.encrypt_msg(SNMP_PRIVPROTOCOL_3DESEDE,
  2156.   key, key_len, msg, 53,
  2157.   enc_buffer, &enc_buffer_len,
  2158.   priv_params, &priv_params_len, 0x5abc, 0x6def);
  2159.   
  2160.   debughexcprintf(1, "encrypted text",
  2161.                   enc_buffer, enc_buffer_len);
  2163.   status = ap.decrypt_msg(SNMP_PRIVPROTOCOL_3DESEDE,
  2164.   key, key_len, enc_buffer, enc_buffer_len,
  2165.   dec_buffer, &dec_buffer_len,
  2166.   priv_params, priv_params_len, 0x5abc, 0x6def);
  2168.   dec_buffer[dec_buffer_len] = 0;
  2169.   debugprintf(1, "decrypted text: %s",
  2170.                   dec_buffer);
  2171.   // TODO: check keys and return real value
  2172.   return true;
  2173. }
  2174. #endif
  2176. #endif // _USE_3DES_EDE
  2179. #ifdef SNMP_PP_NAMESPACE
  2180. }; // end of namespace Snmp_pp
  2181. #endif 
  2183. #endif // _SNMPv3