Paste Search Dynamic
object lifecycles by functions
  1. Newer versions of OpenSSL (v1.1.0+) do not allow direct manipulation of
  2. evp_md_ctx structs, so manage the object lifecycles by functions.
  3.  
  4. ---
  5.  lcptools-v2/hash.c   | 36 ++++++++++++++++++++----------------
  6.  lcptools/hash.c      | 18 ++++++++++--------
  7.  lcptools/mlehash.c   | 10 ++++++----
  8.  tb_polgen/commands.c | 26 ++++++++++++++++----------
  9.  tb_polgen/hash.c     | 18 ++++++++++--------
  10.  5 files changed, 62 insertions(+), 46 deletions(-)
  11.  
  12. diff --git a/lcptools-v2/hash.c b/lcptools-v2/hash.c
  13. index e8e8d72..0fbaecc 100644
  14. --- a/lcptools-v2/hash.c
  15. +++ b/lcptools-v2/hash.c
  16. @@ -82,33 +82,36 @@ bool hash_buffer(const unsigned char* buf, size_t size, tb_hash_t *hash,
  17.          return false;
  18.  
  19.      if ( hash_alg == TB_HALG_SHA1 ) {
  20. -        EVP_MD_CTX ctx;
  21. +        EVP_MD_CTX *ctx = EVP_MD_CTX_create();
  22.          const EVP_MD *md;
  23.  
  24.          md = EVP_sha1();
  25. -        EVP_DigestInit(&ctx, md);
  26. -        EVP_DigestUpdate(&ctx, buf, size);
  27. -        EVP_DigestFinal(&ctx, hash->sha1, null);
  28. +        EVP_DigestInit(ctx, md);
  29. +        EVP_DigestUpdate(ctx, buf, size);
  30. +        EVP_DigestFinal(ctx, hash->sha1, null);
  31. +        EVP_MD_CTX_destroy(ctx);
  32.          return true;
  33.      }
  34.      else if (hash_alg == TB_HALG_SHA256) {
  35. -        EVP_MD_CTX ctx;
  36. +        EVP_MD_CTX *ctx = EVP_MD_CTX_create();
  37.          const EVP_MD *md;
  38.  
  39.          md = EVP_sha256();
  40. -        EVP_DigestInit(&ctx, md);
  41. -        EVP_DigestUpdate(&ctx, buf, size);
  42. -        EVP_DigestFinal(&ctx, hash->sha256, null);
  43. +        EVP_DigestInit(ctx, md);
  44. +        EVP_DigestUpdate(ctx, buf, size);
  45. +        EVP_DigestFinal(ctx, hash->sha256, null);
  46. +        EVP_MD_CTX_destroy(ctx);
  47.          return true;
  48.      }
  49.      else if (hash_alg == TB_HALG_SHA384) {
  50. -        EVP_MD_CTX ctx;
  51. +        EVP_MD_CTX *ctx = EVP_MD_CTX_create();
  52.          const EVP_MD *md;
  53.  
  54.          md = EVP_sha384();
  55. -        EVP_DigestInit(&ctx, md);
  56. -        EVP_DigestUpdate(&ctx, buf, size);
  57. -        EVP_DigestFinal(&ctx, hash->sha384, null);
  58. +        EVP_DigestInit(ctx, md);
  59. +        EVP_DigestUpdate(ctx, buf, size);
  60. +        EVP_DigestFinal(ctx, hash->sha384, null);
  61. +        EVP_MD_CTX_destroy(ctx);
  62.          return true;
  63.      }
  64.      else
  65. @@ -129,15 +132,16 @@ bool extend_hash(tb_hash_t *hash1, const tb_hash_t *hash2, uint16_t hash_alg)
  66.          return false;
  67.  
  68.      if ( hash_alg == TB_HALG_SHA1 ) {
  69. -        EVP_MD_CTX ctx;
  70. +        EVP_MD_CTX *ctx = EVP_MD_CTX_create();
  71.          const EVP_MD *md;
  72.  
  73.          memcpy(buf, &(hash1->sha1), sizeof(hash1->sha1));
  74.          memcpy(buf + sizeof(hash1->sha1), &(hash2->sha1), sizeof(hash1->sha1));
  75.          md = EVP_sha1();
  76. -        EVP_DigestInit(&ctx, md);
  77. -        EVP_DigestUpdate(&ctx, buf, 2*sizeof(hash1->sha1));
  78. -        EVP_DigestFinal(&ctx, hash1->sha1, null);
  79. +        EVP_DigestInit(ctx, md);
  80. +        EVP_DigestUpdate(ctx, buf, 2*sizeof(hash1->sha1));
  81. +        EVP_DigestFinal(ctx, hash1->sha1, null);
  82. +        EVP_MD_CTX_destroy(ctx);
  83.          return true;
  84.      }
  85.      else
  86. diff --git a/lcptools/hash.c b/lcptools/hash.c
  87. index 8f666ac..86338ea 100644
  88. --- a/lcptools/hash.c
  89. +++ b/lcptools/hash.c
  90. @@ -74,13 +74,14 @@ bool hash_buffer(const unsigned char* buf, size_t size, tb_hash_t *hash,
  91.          return false;
  92.  
  93.      if ( hash_alg == TB_HALG_SHA1_LG ) {
  94. -        EVP_MD_CTX ctx;
  95. +        EVP_MD_CTX *ctx = EVP_MD_CTX_create();
  96.          const EVP_MD *md;
  97.  
  98.          md = EVP_sha1();
  99. -        EVP_DigestInit(&ctx, md);
  100. -        EVP_DigestUpdate(&ctx, buf, size);
  101. -        EVP_DigestFinal(&ctx, hash->sha1, null);
  102. +        EVP_DigestInit(ctx, md);
  103. +        EVP_DigestUpdate(ctx, buf, size);
  104. +        EVP_DigestFinal(ctx, hash->sha1, null);
  105. +        EVP_MD_CTX_destroy(ctx);
  106.          return true;
  107.      }
  108.      else
  109. @@ -101,15 +102,16 @@ bool extend_hash(tb_hash_t *hash1, const tb_hash_t *hash2, uint16_t hash_alg)
  110.          return false;
  111.  
  112.      if ( hash_alg == TB_HALG_SHA1_LG ) {
  113. -        EVP_MD_CTX ctx;
  114. +        EVP_MD_CTX *ctx = EVP_MD_CTX_create();
  115.          const EVP_MD *md;
  116.  
  117.          memcpy(buf, &(hash1->sha1), sizeof(hash1->sha1));
  118.          memcpy(buf + sizeof(hash1->sha1), &(hash2->sha1), sizeof(hash1->sha1));
  119.          md = EVP_sha1();
  120. -        EVP_DigestInit(&ctx, md);
  121. -        EVP_DigestUpdate(&ctx, buf, 2*sizeof(hash1->sha1));
  122. -        EVP_DigestFinal(&ctx, hash1->sha1, null);
  123. +        EVP_DigestInit(ctx, md);
  124. +        EVP_DigestUpdate(ctx, buf, 2*sizeof(hash1->sha1));
  125. +        EVP_DigestFinal(ctx, hash1->sha1, null);
  126. +        EVP_MD_CTX_destroy(ctx);
  127.          return true;
  128.      }
  129.      else
  130. diff --git a/lcptools/mlehash.c b/lcptools/mlehash.c
  131. index dc9ddb1..e727c29 100644
  132. --- a/lcptools/mlehash.c
  133. +++ b/lcptools/mlehash.c
  134. @@ -336,7 +336,7 @@ int main(int argc, char* argv[])
  135.      bool help = false;
  136.      char *mle_file;
  137.      extern int optind;    /* current index of get_opt() */
  138. -    EVP_MD_CTX ctx;
  139. +    EVP_MD_CTX *ctx = EVP_MD_CTX_create();
  140.      const EVP_MD *md;
  141.      char *cmdline = null;
  142.  
  143. @@ -418,10 +418,10 @@ int main(int argc, char* argv[])
  144.  
  145.      /* SHA-1 the MLE portion of the image */
  146.      md = EVP_sha1();
  147. -    EVP_DigestInit(&ctx, md);
  148. -    EVP_DigestUpdate(&ctx, exp_start + mle_hdr->mle_start_off,
  149. +    EVP_DigestInit(ctx, md);
  150. +    EVP_DigestUpdate(ctx, exp_start + mle_hdr->mle_start_off,
  151.                       mle_hdr->mle_end_off - mle_hdr->mle_start_off);
  152. -    EVP_DigestFinal(&ctx, (unsigned char *)hash, null);
  153. +    EVP_DigestFinal(ctx, (unsigned char *)hash, null);
  154.      log_info("SHA-1 = ");
  155.  
  156.      /* we always print the hash regardless of verbose mode */
  157. @@ -432,11 +432,13 @@ int main(int argc, char* argv[])
  158.      }
  159.      printf("\n");
  160.  
  161. +    EVP_MD_CTX_destroy(ctx);
  162.      free(base);
  163.      free(exp_start);
  164.      return 0;
  165.  
  166.  error:
  167. +    EVP_MD_CTX_destroy(ctx);
  168.      free(base);
  169.      free(exp_start);
  170.      return 1;
  171. diff --git a/tb_polgen/commands.c b/tb_polgen/commands.c
  172. index 69353a5..892c737 100644
  173. --- a/tb_polgen/commands.c
  174. +++ b/tb_polgen/commands.c
  175. @@ -55,7 +55,6 @@ static bool hash_file(const char *filename, bool unzip, tb_hash_t *hash)
  176.  {
  177.      FILE *f;
  178.      static char buf[1024];
  179. -    EVP_MD_CTX ctx;
  180.      const EVP_MD *md;
  181.      int read_cnt;
  182.  
  183. @@ -69,8 +68,9 @@ static bool hash_file(const char *filename, bool unzip, tb_hash_t *hash)
  184.          return false;
  185.      }
  186.  
  187. +    EVP_MD_CTX *ctx = EVP_MD_CTX_create();
  188.      md = EVP_sha1();
  189. -    EVP_DigestInit(&ctx, md);
  190. +    EVP_DigestInit(ctx, md);
  191.      do {
  192.          if ( unzip )
  193.              read_cnt = gzread((gzFile)f, buf, sizeof(buf));
  194. @@ -79,15 +79,16 @@ static bool hash_file(const char *filename, bool unzip, tb_hash_t *hash)
  195.          if ( read_cnt == 0 )
  196.              break;
  197.  
  198. -        EVP_DigestUpdate(&ctx, buf, read_cnt);
  199. +        EVP_DigestUpdate(ctx, buf, read_cnt);
  200.      } while ( true );
  201. -    EVP_DigestFinal(&ctx, hash->sha1, null);
  202. +    EVP_DigestFinal(ctx, hash->sha1, null);
  203.  
  204.      if ( unzip )
  205.          gzclose((gzFile)f);
  206.      else
  207.          fclose(f);
  208.  
  209. +    EVP_MD_CTX_destroy(ctx);
  210.      return true;
  211.  }
  212.  
  213. @@ -165,17 +166,17 @@ bool do_add(const param_data_t *params)
  214.  
  215.      /* hash command line and files */
  216.      if ( params->hash_type == TB_HTYPE_IMAGE ) {
  217. -        EVP_MD_CTX ctx;
  218. +        EVP_MD_CTX *ctx = EVP_MD_CTX_create();
  219.          const EVP_MD *md;
  220.          tb_hash_t final_hash, hash;
  221.  
  222.          /* hash command line */
  223.          info_msg("hashing command line \"%s\"...\n", params->cmdline);
  224.          md = EVP_sha1();
  225. -        EVP_DigestInit(&ctx, md);
  226. -        EVP_DigestUpdate(&ctx, (unsigned char *)params->cmdline,
  227. +        EVP_DigestInit(ctx, md);
  228. +        EVP_DigestUpdate(ctx, (unsigned char *)params->cmdline,
  229.                           strlen(params->cmdline));
  230. -        EVP_DigestFinal(&ctx, (unsigned char *)&final_hash, null);
  231. +        EVP_DigestFinal(ctx, (unsigned char *)&final_hash, null);
  232.          if ( verbose ) {
  233.              info_msg("hash is...");
  234.              print_hash(&final_hash, TB_HALG_SHA1);
  235. @@ -183,15 +184,19 @@ bool do_add(const param_data_t *params)
  236.  
  237.          /* hash file */
  238.          info_msg("hashing image file %s...\n", params->image_file);
  239. -        if ( !hash_file(params->image_file, true, &hash) )
  240. +        if ( !hash_file(params->image_file, true, &hash) ) {
  241. +            EVP_MD_CTX_destroy(ctx);
  242.              return false;
  243. +        }
  244.          if ( verbose ) {
  245.              info_msg("hash is...");
  246.              print_hash(&hash, TB_HALG_SHA1);
  247.          }
  248.  
  249. -        if ( !extend_hash(&final_hash, &hash, TB_HALG_SHA1) )
  250. +        if ( !extend_hash(&final_hash, &hash, TB_HALG_SHA1) ) {
  251. +            EVP_MD_CTX_destroy(ctx);
  252.              return false;
  253. +        }
  254.  
  255.          if ( verbose ) {
  256.              info_msg("cummulative hash is...");
  257. @@ -200,6 +205,7 @@ bool do_add(const param_data_t *params)
  258.  
  259.          if ( !add_hash(pol_entry, &final_hash) ) {
  260.              error_msg("cannot add another hash\n");
  261. +            EVP_MD_CTX_destroy(ctx);
  262.              return false;
  263.          }
  264.      }
  265. diff --git a/tb_polgen/hash.c b/tb_polgen/hash.c
  266. index f6ffb38..8ae06ab 100644
  267. --- a/tb_polgen/hash.c
  268. +++ b/tb_polgen/hash.c
  269. @@ -83,13 +83,14 @@ bool hash_buffer(const unsigned char* buf, size_t size, tb_hash_t *hash,
  270.      }
  271.  
  272.      if ( hash_alg == TB_HALG_SHA1 ) {
  273. -        EVP_MD_CTX ctx;
  274. +        EVP_MD_CTX *ctx = EVP_MD_CTX_create();
  275.          const EVP_MD *md;
  276.  
  277.          md = EVP_sha1();
  278. -        EVP_DigestInit(&ctx, md);
  279. -        EVP_DigestUpdate(&ctx, buf, size);
  280. -        EVP_DigestFinal(&ctx, hash->sha1, null);
  281. +        EVP_DigestInit(ctx, md);
  282. +        EVP_DigestUpdate(ctx, buf, size);
  283. +        EVP_DigestFinal(ctx, hash->sha1, null);
  284. +        EVP_MD_CTX_destroy(ctx);
  285.          return true;
  286.      }
  287.      else {
  288. @@ -114,15 +115,16 @@ bool extend_hash(tb_hash_t *hash1, const tb_hash_t *hash2, uint16_t hash_alg)
  289.      }
  290.  
  291.      if ( hash_alg == TB_HALG_SHA1 ) {
  292. -        EVP_MD_CTX ctx;
  293. +        EVP_MD_CTX *ctx = EVP_MD_CTX_create();
  294.          const EVP_MD *md;
  295.  
  296.          memcpy(buf, &(hash1->sha1), sizeof(hash1->sha1));
  297.          memcpy(buf + sizeof(hash1->sha1), &(hash2->sha1), sizeof(hash1->sha1));
  298.          md = EVP_sha1();
  299. -        EVP_DigestInit(&ctx, md);
  300. -        EVP_DigestUpdate(&ctx, buf, 2*sizeof(hash1->sha1));
  301. -        EVP_DigestFinal(&ctx, hash1->sha1, null);
  302. +        EVP_DigestInit(ctx, md);
  303. +        EVP_DigestUpdate(ctx, buf, 2*sizeof(hash1->sha1));
  304. +        EVP_DigestFinal(ctx, hash1->sha1, null);
  305. +        EVP_MD_CTX_destroy(ctx);
  306.          return true;
  307.      }
  308.      else {
  309. --
  310. 2.6.4
  311.  
  312.  
Parsed in 0.075 seconds