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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
scapi.c
资源名称：snmp.src.rar　[点击查看]
上传用户：cxs890
上传日期：2021-05-22
资源大小：347k
文件大小：18k
源码类别：

SNMP编程

开发平台：

C/C++

scapi.c：源码内容
  1. /*
  2.  * scapi.c
  3.  *
  4.  */
  6. #include <config.h>
  8. #include <sys/types.h>
  9. #if HAVE_WINSOCK_H
  10. #include <ip/socket.h>
  11. #endif
  12. #ifdef HAVE_STDLIB_H
  13. #include <stdlib.h>
  14. #endif
  15. #if HAVE_STRING_H
  16. #include <string.h>
  17. #else
  18. #include <strings.h>
  19. #endif
  20. #if TIME_WITH_SYS_TIME
  21. # ifdef WIN32
  22. #  include <sys/timeb.h>
  23. # else
  24. #  include <time.h>
  25. # endif
  26. # include <time.h>
  27. #else
  28. # if HAVE_SYS_TIME_H
  29. #  include <sys/time.h>
  30. # else
  31. #  include <time.h>
  32. # endif
  33. #endif
  34. #ifdef OS_VXWORKS
  35. #include <sys/times.h>
  36. #endif
  37. #ifdef HAVE_NETINET_IN_H
  38. #include <netinet/in.h>
  39. #endif
  41. #include <libsys/des.h>
  43. #ifdef USE_INTERNAL_MD5
  44. #include "md5.h"
  45. #endif
  46. #include "asn1.h"
  47. #include "tools.h"
  48. #include "snmp_api.h"
  49. #include "callback.h"
  50. #include "snmpusm.h"
  51. #include "keytools.h"
  52. #include "snmp_debug.h"
  53. #include "scapi.h"
  54. #include "snmp_impl.h"
  55. #include "system.h"
  57. #include "transform_oids.h"
  59. #ifdef USE_OPENSSL
  60. #include <openssl/hmac.h>
  61. #include <openssl/evp.h>
  62. #include <openssl/rand.h>
  63. #endif
  64. #ifdef SWITCH
  65. #include <libsys/sha.h>
  66. #endif
  67. #include <libsys/md5.h>
  69. #ifdef QUITFUN
  70. #undef QUITFUN
  71. #define QUITFUN(e, l)
  72. if (e != SNMPERR_SUCCESS) {
  73. rval = SNMPERR_SC_GENERAL_FAILURE;
  74. goto l ;
  75. }
  76. #endif
  78. extern void hmac_sha ( char* d,  int  ld,  char*  k, int  lk,   char* out );
  79. /*
  80.   sc_get_properlength(oid *hashtype, u_int hashtype_len):
  82.   Given a hashing type ("hashtype" and its length hashtype_len), return
  83.   the length of the hash result.
  85.   Returns either the length or SNMPERR_GENERR for an unknown hashing type.
  86. */
  87. int
  88. sc_get_properlength(oid *hashtype, u_int hashtype_len)
  89. {
  90.   DEBUGTRACE;
  91.   /*
  92.    * Determine transform type hash length.
  93.    */
  94.   if ( ISTRANSFORM(hashtype, HMACMD5Auth)) {
  95.     return BYTESIZE(SNMP_TRANS_AUTHLEN_HMACMD5);
  96.   }
  97.   else if ( ISTRANSFORM(hashtype, HMACSHA1Auth) ) {
  98.     return BYTESIZE(SNMP_TRANS_AUTHLEN_HMACSHA1);
  99.   }
  100.   return SNMPERR_GENERR;
  101. }
  104. /*******************************************************************-o-******
  105.  * sc_init
  106.  *
  107.  * Returns:
  108.  * SNMPERR_SUCCESS Success.
  109.  */
  110. int
  111. sc_init(void)
  112. {
  113.   int rval = SNMPERR_SUCCESS;
  115. #ifndef USE_OPENSSL
  116. #ifdef USE_INTERNAL_MD5
  117.   struct timeval tv;
  118.   
  119.   DEBUGTRACE;
  121.   gettimeofday(&tv,(struct timezone *)0);
  122.   
  123.   srandom(tv.tv_sec ^ tv.tv_usec);
  124. #else
  125.   rval = SNMPERR_SC_NOT_CONFIGURED;
  126. #endif
  127.   /* XXX ogud: The only reason to do anything here with openssl is to 
  128.    * XXX ogud: seed random number generator 
  129.    */
  130. #endif  /* ifndef USE_OPENSSL */
  131. return rval;
  132. }  /* end sc_init() */
  134. /*******************************************************************-o-******
  135.  * sc_random
  136.  *
  137.  * Parameters:
  138.  * *buf Pre-allocated buffer.
  139.  * *buflen  Size of buffer.
  140.  *      
  141.  * Returns:
  142.  * SNMPERR_SUCCESS Success.
  143.  */
  144. int
  145. sc_random(u_char *buf, size_t *buflen)
  146. {
  147. #ifdef INCLUDE_SNMPV3
  148.   int rval = SNMPERR_SUCCESS;
  149. #ifdef USE_INTERNAL_MD5
  150.   int i;
  151.   int rndval;
  152.   u_char *ucp = buf;
  153. #endif
  155.   DEBUGTRACE;
  157. #ifdef USE_OPENSSL
  158.   RAND_bytes(buf, *buflen); /* will never fail */
  159. #else /* USE_INTERNAL_MD5 */
  160.   /* fill the buffer with random integers.  Note that random()
  161.      is defined in config.h and may not be truly the random()
  162.      system call if something better existed */
  163.   rval = *buflen - *buflen%sizeof(rndval);
  164.   for(i = 0; i < rval; i += sizeof(rndval)) {
  165.     rndval = random();
  166.     memcpy(ucp, &rndval, sizeof(rndval));
  167.     ucp += sizeof(rndval);
  168.   }
  169.   
  170.   rndval = random();
  171.   memcpy(ucp, &rndval, *buflen%sizeof(rndval));
  172.   
  173.   rval = SNMPERR_SUCCESS;
  174. #endif  /* USE_OPENSSL */
  175.   return rval;
  177. #else
  178. return -1;
  179. #endif /*  */
  180. }  /* end sc_random() */
  185. /*******************************************************************-o-******
  186.  * sc_generate_keyed_hash
  187.  *
  188.  * Parameters:
  189.  *  authtype Type of authentication transform.
  190.  *  authtypelen
  191.  * *key Pointer to key (Kul) to use in keyed hash.
  192.  *  keylen Length of key in bytes.
  193.  * *message Pointer to the message to hash.
  194.  *  msglen Length of the message.
  195.  * *MAC Will be returned with allocated bytes containg hash.
  196.  * *maclen Length of the hash buffer in bytes; also indicates
  197.  * whether the MAC should be truncated.
  198.  *      
  199.  * Returns:
  200.  * SNMPERR_SUCCESS Success.
  201.  * SNMPERR_GENERR All errs
  202.  *
  203.  *
  204.  * A hash of the first msglen bytes of message using a keyed hash defined
  205.  * by authtype is created and stored in MAC.  MAC is ASSUMED to be a buffer
  206.  * of at least maclen bytes.  If the length of the hash is greater than
  207.  * maclen, it is truncated to fit the buffer.  If the length of the hash is
  208.  * less than maclen, maclen set to the number of hash bytes generated.
  209.  *
  210.  * ASSUMED that the number of hash bits is a multiple of 8.
  211.  */
  212. int
  213. sc_generate_keyed_hash( oid *authtype, size_t authtypelen,
  214. u_char *key, u_int  keylen,
  215. u_char *message, u_int  msglen,
  216. u_char *MAC, size_t *maclen)
  217. {
  218. #ifdef INCLUDE_SNMPV3
  219.   int  rval  = SNMPERR_SUCCESS;
  220.   int  properlength;
  222.   u_char  buf[SNMP_MAXBUF_SMALL];
  223. #if  defined(USE_OPENSSL)
  224.   int  buf_len = sizeof(buf);
  225.   u_char *bufp = buf;
  226. #endif
  227.   
  228.   DEBUGTRACE;
  230. #ifdef SNMP_TESTING_CODE
  231. {
  232.   int i;
  233.   DEBUGMSG(("sc_generate_keyed_hash", "sc_generate_keyed_hash(): key=0x"));
  234.   for(i=0; i< keylen; i++)
  235.     DEBUGMSG(("sc_generate_keyed_hash", "%02x", key[i] & 0xff));
  236.   DEBUGMSG(("sc_generate_keyed_hash"," (%d)n", keylen));
  237. }
  238. #endif /* SNMP_TESTING_CODE */
  240. /*
  241.  * Sanity check.
  242.  */
  243.  if ( !authtype || !key || !message || !MAC || !maclen
  244.       || (keylen<=0) || (msglen<=0) || (*maclen<=0)
  245.       || (authtypelen != USM_LENGTH_OID_TRANSFORM) )
  246.    {
  247.      QUITFUN(SNMPERR_GENERR, sc_generate_keyed_hash_quit);
  248.    }
  249.  
  250.  properlength = sc_get_properlength(authtype, authtypelen);
  251.  if (properlength == SNMPERR_GENERR)
  252.    return properlength;
  253.  
  254.  if ( ((int)keylen < properlength) ) {
  255.    QUITFUN(SNMPERR_GENERR, sc_generate_keyed_hash_quit);
  256.  }
  257.  
  259. #ifdef USE_OPENSSL
  260.  /*
  261.   * Determine transform type.
  262.   */
  263.    if (ISTRANSFORM(authtype, HMACMD5Auth))
  264.      HMAC(EVP_md5(), key, keylen, message, msglen,  
  265.   buf, &buf_len);
  266.    else if (ISTRANSFORM(authtype, HMACSHA1Auth)) 
  267.      HMAC(EVP_sha1(), key, keylen, message, msglen,  
  268.   buf, &buf_len);
  269.    else {
  270.      QUITFUN(SNMPERR_GENERR, sc_generate_keyed_hash_quit);
  271.    }
  272.    if (buf_len != properlength) {
  273.      QUITFUN(rval, sc_generate_keyed_hash_quit);
  274.    }
  275.    if (*maclen > buf_len) 
  276.      *maclen = buf_len;
  277.    memcpy(MAC, buf, *maclen);
  278. #else 
  279.  if ((int)*maclen > properlength)
  280.    *maclen = properlength;
  282.    if (ISTRANSFORM(authtype, HMACMD5Auth))
  283.      hmac_md5(message, msglen, key, keylen, MAC);
  284.    else if (ISTRANSFORM(authtype, HMACSHA1Auth))
  285.      hmac_sha(message, msglen, key, keylen, MAC);
  286.    else {
  287.      QUITFUN(SNMPERR_GENERR, sc_generate_keyed_hash_quit);
  288.    }
  289. #endif /* USE_OPENSSL */
  291. #ifdef SNMP_TESTING_CODE
  292.  {
  293.    char    *s;
  294.    int      len = binary_to_hex(MAC, *maclen, &s);
  295.    
  296.    DEBUGMSGTL(("scapi","Full v3 message hash: %sn", s));
  297.    SNMP_ZERO(s, len);
  298.    SNMP_FREE(s);
  299.  }
  300. #endif
  301.  
  302.  sc_generate_keyed_hash_quit:
  303.  SNMP_ZERO(buf, SNMP_MAXBUF_SMALL);
  304.  return rval;
  305. #else
  306. return -1;
  307. #endif /* */
  308. }  /* end sc_generate_keyed_hash() */
  312. /* sc_hash(): a generic wrapper around whatever hashing package we are using.
  314.    IN:
  315.      hashtype    - oid pointer to a hash type
  316.      hashtypelen - length of oid pointer
  317.      buf         - u_char buffer to be hashed
  318.      buf_len     - integer length of buf data
  319.      MAC_len     - length of the passed MAC buffer size.
  320.     
  321.    OUT:    
  322.      MAC         - pre-malloced space to store hash output.
  323.      MAC_len     - length of MAC output to the MAC buffer.
  325.    Returns:
  326.      SNMPERR_SUCCESS Success.
  327.      SNMP_SC_GENERAL_FAILURE Any error.
  328. */
  330. int
  331. sc_hash(oid *hashtype, size_t hashtypelen, u_char *buf, size_t buf_len,
  332.         u_char *MAC, size_t *MAC_len)
  333. {
  334. #ifdef INCLUDE_SNMPV3
  336. #ifdef USE_OPENSSL 
  337.   int   rval       = SNMPERR_SUCCESS;
  338.   EVP_MD *hash(void);
  339.   HMAC_CTX *c = NULL; 
  340. #endif
  342.   DEBUGTRACE;
  344.   if (hashtype == NULL || hashtypelen < 0 || buf == NULL ||
  345.       buf_len < 0 || MAC == NULL ||  MAC_len == NULL ||
  346.       (int)(*MAC_len) < sc_get_properlength(hashtype, hashtypelen))
  347.     return (SNMPERR_GENERR);
  349. #ifdef USE_OPENSSL 
  350.   /*
  351.    * Determine transform type.
  352.    */
  353.   c = malloc(sizeof(HMAC_CTX));
  354.   if (c == NULL)
  355.     return (SNMPERR_GENERR);
  357.   if (ISTRANSFORM(hashtype, HMACMD5Auth)) {
  358.     EVP_DigestInit(&c->md_ctx, (const EVP_MD *) EVP_md5());
  359.   }
  360.   else if (ISTRANSFORM(hashtype, HMACSHA1Auth)) {
  361.     EVP_DigestInit(&c->md_ctx, (const EVP_MD *) EVP_sha1());
  362.   }
  363.   else {
  364.     return(SNMPERR_GENERR);
  365.   }
  366.   EVP_DigestUpdate(&c->md_ctx, buf, buf_len);
  367.   EVP_DigestFinal(&(c->md_ctx), MAC, MAC_len);
  368.   free(c);
  369.   return (rval);
  370. #else /* USE_INTERNAL_MD5 */
  372.   if (ISTRANSFORM(hashtype, HMACMD5Auth)) {
  373.     md5Digest(buf, buf_len, MAC);
  374.   }
  375.   else if (ISTRANSFORM(hashtype, HMACSHA1Auth)) {
  376.     SHABlock(buf, buf_len, MAC);
  377.   }
  378.   else
  379.     return(SNMPERR_GENERR);
  381.   if (*MAC_len > 16)
  382.     *MAC_len = 16;
  383.   return SNMPERR_SUCCESS;
  384. #endif
  385. #else 
  386. return -1;
  387. #endif /* INCLUDE_SNMPV3 */
  388. }
  392. /*******************************************************************-o-******
  393.  * sc_check_keyed_hash
  394.  *
  395.  * Parameters:
  396.  *  authtype Transform type of authentication hash.
  397.  * *key Key bits in a string of bytes.
  398.  *  keylen Length of key in bytes.
  399.  * *message Message for which to check the hash.
  400.  *  msglen Length of message.
  401.  * *MAC Given hash.
  402.  *  maclen Length of given hash; indicates truncation if it is
  403.  * shorter than the normal size of output for
  404.  * given hash transform.
  405.  * Returns:
  406.  * SNMPERR_SUCCESS Success.
  407.  * SNMP_SC_GENERAL_FAILURE Any error
  408.  *
  409.  *
  410.  * Check the hash given in MAC against the hash of message.  If the length
  411.  * of MAC is less than the length of the transform hash output, only maclen
  412.  * bytes are compared.  The length of MAC cannot be greater than the
  413.  * length of the hash transform output.
  414.  */
  415. int
  416. sc_check_keyed_hash( oid *authtype, size_t authtypelen,
  417. u_char *key, u_int keylen,
  418. u_char *message, u_int msglen,
  419. u_char *MAC, u_int maclen)
  420. {
  421. #ifdef INCLUDE_SNMPV3
  422. int  rval  = SNMPERR_SUCCESS;
  423. size_t  buf_len = SNMP_MAXBUF_SMALL;
  425. u_char  buf[SNMP_MAXBUF_SMALL];
  427.         DEBUGTRACE;
  429. #ifdef SNMP_TESTING_CODE
  430. {
  431.  int i;
  432.  DEBUGMSG(("scapi", "sc_check_keyed_hash():    key=0x"));
  433.  for(i=0; i< keylen; i++)
  434.    DEBUGMSG(("scapi", "%02x", key[i] & 0xff));
  435.  DEBUGMSG(("scapi"," (%d)n", keylen));
  436. }
  437. #endif /* SNMP_TESTING_CODE */
  439. /*
  440.  * Sanity check.
  441.  */
  442. if ( !authtype || !key || !message || !MAC 
  443. || (keylen<=0) || (msglen<=0) || (maclen<=0)
  444. || (authtypelen != USM_LENGTH_OID_TRANSFORM) )
  445. {
  446. QUITFUN(SNMPERR_GENERR, sc_check_keyed_hash_quit);
  447. }
  450. /* 
  451.  * Generate a full hash of the message, then compare
  452.  * the result with the given MAC which may shorter than
  453.  * the full hash length.
  454.  */
  455. rval = sc_generate_keyed_hash( authtype, authtypelen,
  456. key, keylen,
  457. message, msglen,
  458. buf, &buf_len);
  459. QUITFUN(rval, sc_check_keyed_hash_quit);
  461. if (maclen > msglen) {
  462. QUITFUN(SNMPERR_GENERR, sc_check_keyed_hash_quit);
  464. } else if ( memcmp(buf, MAC, maclen) != 0 ) {
  465. QUITFUN(SNMPERR_GENERR, sc_check_keyed_hash_quit);
  466. }
  469. sc_check_keyed_hash_quit:
  470. SNMP_ZERO(buf, SNMP_MAXBUF_SMALL);
  472. return rval;
  473. #else
  474. return -1;
  475. #endif /*INCLUDE_SNMPV3*/
  476. }  /* end sc_check_keyed_hash() */
  479. /*******************************************************************-o-******
  480.  * sc_encrypt
  481.  *
  482.  * Parameters:
  483.  *  privtype Type of privacy cryptographic transform.
  484.  * *key Key bits for crypting.
  485.  *  keylen Length of key (buffer) in bytes.
  486.  * *iv IV bits for crypting.
  487.  *  ivlen Length of iv (buffer) in bytes.
  488.  * *plaintext Plaintext to crypt.
  489.  *  ptlen Length of plaintext.
  490.  * *ciphertext Ciphertext to crypt.
  491.  * *ctlen Length of ciphertext.
  492.  *      
  493.  * Returns:
  494.  * SNMPERR_SUCCESS Success.
  495.  * SNMPERR_SC_NOT_CONFIGURED Encryption is not supported.
  496.  * SNMPERR_SC_GENERAL_FAILURE Any other error
  497.  *
  498.  *
  499.  * Encrypt plaintext into ciphertext using key and iv.
  500.  *
  501.  * ctlen contains actual number of crypted bytes in ciphertext upon
  502.  * successful return.
  503.  */
  504. int
  505. sc_encrypt( oid    *privtype, size_t privtypelen,
  506. u_char *key, u_int  keylen,
  507. u_char *iv, u_int  ivlen,
  508. u_char *plaintext, u_int  ptlen,
  509. u_char *ciphertext, size_t *ctlen)
  510. {
  511. #ifdef INCLUDE_SNMPV3
  512. int rval = SNMPERR_SUCCESS;
  513. /* u_int transform;*/
  514. u_int properlength,
  515.        properlength_iv;
  516. u_char pad_block[128];  /* bigger than anything I need */
  517. u_char          my_iv[128];      /* ditto */
  518. int pad, plast, pad_size;
  519. des_key_schedule key_sch;
  520. des_cblock      key_struct;
  522.         DEBUGTRACE;
  524. /*
  525.  * Sanity check.
  526.  */
  527. #if !defined(SCAPI_AUTHPRIV)
  528. return SNMPERR_SC_NOT_CONFIGURED;
  529. #endif
  531. if ( !privtype || !key || !iv || !plaintext || !ciphertext || !ctlen
  532. || (keylen<=0) || (ivlen<=0) || (ptlen<=0) || (*ctlen<=0)
  533. || (privtypelen != USM_LENGTH_OID_TRANSFORM) )
  534. {
  535. QUITFUN(SNMPERR_GENERR, sc_encrypt_quit);
  536. }
  537. else if ( ptlen > *ctlen) { 
  538. QUITFUN(SNMPERR_GENERR, sc_encrypt_quit);
  539. }
  542. #ifdef SNMP_TESTING_CODE
  543. {
  544.         char buf[SNMP_MAXBUF];
  546. sprint_hexstring(buf, iv, ivlen);
  547.         DEBUGMSGTL(("scapi", "encrypt: IV: %s/ ", buf));
  548. sprint_hexstring(buf, key, keylen);
  549.         DEBUGMSG(("scapi","%sn", buf));
  551. sprint_hexstring(buf, plaintext, 16);
  552.         DEBUGMSGTL(("scapi","encrypt: string: %sn", buf));
  553. }
  554. #endif /* SNMP_TESTING_CODE */
  557. /*
  558.  * Determine privacy transform.
  559.  */
  560. if ( ISTRANSFORM(privtype, DESPriv) ) {
  561. properlength = BYTESIZE(SNMP_TRANS_PRIVLEN_1DES);
  562. properlength_iv = BYTESIZE(SNMP_TRANS_PRIVLEN_1DES_IV);
  563. pad_size = properlength;
  564. } else {
  565. QUITFUN(SNMPERR_GENERR, sc_encrypt_quit);
  566. }
  568. if ( (keylen<properlength) || (ivlen<properlength_iv) ) {
  569. QUITFUN(SNMPERR_GENERR, sc_encrypt_quit);
  570. }
  572. else if ( (keylen<properlength) || (ivlen<properlength_iv) ) {
  573. QUITFUN(SNMPERR_GENERR, sc_encrypt_quit);
  574. }
  576. /* now calculate the padding needed */
  577. pad = pad_size - (ptlen % pad_size);
  578.     plast = (int) ptlen - (pad_size - pad);
  579.     if (pad == pad_size)
  580.         pad = 0;
  581. if (ptlen + pad > *ctlen) { 
  582. QUITFUN(SNMPERR_GENERR, sc_encrypt_quit); /* not enough space */
  583. }
  584. /* memset(pad_block, 0, sizeof(pad_block));
  585. plast = (int) ptlen - (pad_size - pad);*/
  586. if (pad > 0)  /* copy data into pad block if needed */ {
  587. memcpy( pad_block, plaintext + plast, pad_size - pad);
  588.      memset(&pad_block[pad_size-pad], pad, pad); /* filling in padblock */
  589. }
  591. memset(my_iv, 0, sizeof(my_iv));
  593. if ( ISTRANSFORM(privtype, DESPriv) ) {
  594.                 memcpy(key_struct, key, sizeof(key_struct));
  595. (void) DES_key_sched(&key_struct, key_sch);
  597. memcpy(my_iv, iv, ivlen);
  598. /* encrypt the data */
  599. DES_ncbc_encrypt(plaintext, ciphertext, plast, key_sch, 
  600.  (des_cblock *) &my_iv, DES_ENCRYPT);
  601. /* then encrypt the pad block */
  602. if (pad > 0) {
  603.      DES_ncbc_encrypt(pad_block, ciphertext+plast, pad_size, 
  604.       key_sch, (des_cblock *)&my_iv, DES_ENCRYPT);
  605.      *ctlen = plast + pad_size;
  606. } else {
  607.     *ctlen = plast;
  608. }
  609. }
  610. sc_encrypt_quit:
  611. /* clear memory just in case */
  612. memset(my_iv, 0, sizeof(my_iv));
  613. memset(pad_block, 0, sizeof(pad_block));
  614. memset(key_struct, 0, sizeof(key_struct));
  615. memset(key_sch, 0, sizeof(key_sch));
  616. return rval;
  617. #else
  618. return -1;
  619. #endif /*INCLUDE_SNMPV3*/
  620. }  /* end sc_encrypt() */
  625. /*******************************************************************-o-******
  626.  * sc_decrypt
  627.  *
  628.  * Parameters:
  629.  *  privtype
  630.  * *key
  631.  *  keylen
  632.  * *iv
  633.  *  ivlen
  634.  * *ciphertext
  635.  *  ctlen
  636.  * *plaintext
  637.  * *ptlen
  638.  *      
  639.  * Returns:
  640.  * SNMPERR_SUCCESS Success.
  641.  * SNMPERR_SC_NOT_CONFIGURED Encryption is not supported.
  642.  *      SNMPERR_SC_GENERAL_FAILURE      Any other error
  643.  *
  644.  *
  645.  * Decrypt ciphertext into plaintext using key and iv.
  646.  *
  647.  * ptlen contains actual number of plaintext bytes in plaintext upon
  648.  * successful return.
  649.  */
  650. int
  651. sc_decrypt( oid    *privtype, size_t privtypelen,
  652. u_char *key, u_int  keylen,
  653. u_char *iv, u_int  ivlen,
  654. u_char *ciphertext, u_int  ctlen,
  655. u_char *plaintext, size_t *ptlen)
  656. {
  657. #ifdef INCLUDE_SNMPV3
  658. int rval = SNMPERR_SUCCESS;
  659. /* int i, j;*/ 
  660. u_char my_iv[128];
  661. des_key_schedule key_sch;
  662. des_cblock  key_struct;
  663. u_int properlength,
  664. properlength_iv;
  666.         DEBUGTRACE;
  668. if ( !privtype || !key || !iv || !plaintext || !ciphertext || !ptlen
  669. || (ctlen<=0) || (*ptlen<=0) || (*ptlen < ctlen)
  670. || (privtypelen != USM_LENGTH_OID_TRANSFORM) )
  671. {
  672. QUITFUN(SNMPERR_GENERR, sc_decrypt_quit);
  673. }
  676. #ifdef SNMP_TESTING_CODE
  677. {
  678.         char buf[SNMP_MAXBUF];
  680. sprint_hexstring(buf, iv, ivlen);
  681.         DEBUGMSGTL(("scapi", "decrypt: IV: %s/ ", buf));
  682. sprint_hexstring(buf, key, keylen);
  683.         DEBUGMSG(("scapi","%sn", buf));
  684. }
  685. #endif /* SNMP_TESTING_CODE */
  687. /*
  688.  * Determine privacy transform.
  689.  */
  690. if ( ISTRANSFORM(privtype, DESPriv) ) {
  691. properlength = BYTESIZE(SNMP_TRANS_PRIVLEN_1DES);
  692. properlength_iv = BYTESIZE(SNMP_TRANS_PRIVLEN_1DES_IV);
  694. } else {
  695. QUITFUN(SNMPERR_GENERR, sc_decrypt_quit);
  696. }
  698. if ( (keylen<properlength) || (ivlen<properlength_iv) ) {
  699. QUITFUN(SNMPERR_GENERR, sc_decrypt_quit);
  700. }
  702. memset(my_iv, 0, sizeof(my_iv));
  703. if (ISTRANSFORM(privtype, DESPriv)) {
  704.                 memcpy(key_struct, key, sizeof(key_struct));
  705. (void) /*des_key_sched*/DES_key_sched(&key_struct, key_sch);
  707. memcpy(my_iv, iv, ivlen);
  708. /*des_cbc_encrypt*/DES_cbc_encrypt(ciphertext, plaintext, ctlen, key_sch, 
  709. (des_cblock *) &my_iv, DES_DECRYPT);
  710.         *ptlen = ctlen;
  711. }
  713. /* exit cond */
  714. sc_decrypt_quit:
  715. memset(key_sch, 0, sizeof(key_sch));
  716. memset(key_struct, 0, sizeof(key_struct));
  717. memset(my_iv, 0, sizeof(my_iv));
  718. return rval;
  719. #else
  720. return -1;
  721. #endif /*INCLUDE_SNMPV3*/
  722. }