openssl.patch

   1 --- poldek-0.32.2/tndb/read.c~  2016-01-30 17:59:59.000000000 +0100
   2 +++ poldek-0.32.2/tndb/read.c   2018-09-14 18:35:56.516594794 +0200
   3 @@ -53,20 +53,22 @@ static
   4  int md5(FILE *stream, unsigned char *md, unsigned *md_size)
   5  {
   6      unsigned char buf[8*1024];
   7 -    EVP_MD_CTX ctx;
   8 +    EVP_MD_CTX *ctx;
   9      unsigned n, nn = 0;
  10
  11
  12      n_assert(md_size && *md_size);
  13
  14 -    EVP_DigestInit(&ctx, EVP_md5());
  15 +    ctx = EVP_MD_CTX_create();
  16 +    if (!EVP_DigestInit(ctx, EVP_md5()))
  17 +        return 0;
  18
  19      while ((n = fread(buf, 1, sizeof(buf), stream)) > 0) {
  20 -        EVP_DigestUpdate(&ctx, buf, n);
  21 +        EVP_DigestUpdate(ctx, buf, n);
  22          nn += n;
  23      }
  24
  25 -    EVP_DigestFinal(&ctx, buf, &n);
  26 +    EVP_DigestFinal(ctx, buf, &n);
  27
  28      if (n > *md_size) {
  29          *md = '\0';
  30 @@ -75,7 +77,9 @@ int md5(FILE *stream, unsigned char *md,
  31          memcpy(md, buf, n);
  32          *md_size = n;
  33      }
  34 -
  35 +
  36 +    EVP_MD_CTX_destroy(ctx);
  37 +
  38      return *md_size;
  39  }
  40
  41 --- poldek-0.32.2/tndb/tndb.c~  2016-01-30 17:59:59.000000000 +0100
  42 +++ poldek-0.32.2/tndb/tndb.c   2018-09-14 18:40:57.805504132 +0200
  43 @@ -85,13 +85,13 @@ char *tndb_bin2hex_s(const unsigned char
  44  //static
  45  void tndb_sign_init(struct tndb_sign *sign)
  46  {
  47 -    EVP_MD_CTX ctx;
  48 +    EVP_MD_CTX *ctx;
  49
  50      memset(sign, 0, sizeof(*sign));
  51
  52 -    EVP_DigestInit(&ctx, EVP_sha1());
  53 -    sign->ctx = n_malloc(sizeof(ctx));
  54 -    memcpy(sign->ctx, &ctx, sizeof(ctx));
  55 +    ctx = EVP_MD_CTX_create();
  56 +    EVP_DigestInit(ctx, EVP_sha1());
  57 +    sign->ctx = ctx;
  58      //printf("%p %p >> INIT\n", sign, sign->ctx);
  59  }
  60
  61 @@ -122,8 +122,8 @@ void tndb_sign_final(struct tndb_sign *s
  62          *sign->md = '\0';
  63      else
  64          memcpy(sign->md, buf, n);
  65 -
  66 -    free(sign->ctx);
  67 +
  68 +    EVP_MD_CTX_destroy((EVP_MD_CTX *)sign->ctx);
  69      sign->ctx = NULL;
  70
  71  }
  72 --- poldek-0.32.2/pkgdir/pdir/digest.c~ 2016-01-30 15:05:57.000000000 +0100
  73 +++ poldek-0.32.2/pkgdir/pdir/digest.c  2018-09-14 18:52:42.783229333 +0200
  74 @@ -195,12 +195,13 @@ int hdr_digest(tn_stream *st, unsigned c
  75      int             nread, len, endvhdr_found = 0;
  76      unsigned char   buf[256];
  77      char            line[4096];
  78 -    EVP_MD_CTX      ctx;
  79 +    EVP_MD_CTX      *ctx;
  80      unsigned        n;
  81
  82
  83      n_assert(md_size && *md_size);
  84 -    EVP_DigestInit(&ctx, EVP_sha1());
  85 +    ctx = EVP_MD_CTX_create();
  86 +    EVP_DigestInit(ctx, EVP_sha1());
  87
  88      len = strlen(pdir_tag_endvarhdr);
  89      n = 0;
  90 @@ -208,7 +209,7 @@ int hdr_digest(tn_stream *st, unsigned c
  91      while ((nread = n_stream_gets(st, line, sizeof(line))) > 0) {
  92          char *p = line;
  93
  94 -        EVP_DigestUpdate(&ctx, line, nread);
  95 +        EVP_DigestUpdate(ctx, line, nread);
  96          if (_ctx)
  97              EVP_DigestUpdate(_ctx, line, nread);
  98          n++;
  99 @@ -228,7 +229,8 @@ int hdr_digest(tn_stream *st, unsigned c
 100              break;
 101      }
 102
 103 -    EVP_DigestFinal(&ctx, buf, &n);
 104 +    EVP_DigestFinal(ctx, buf, &n);
 105 +    EVP_MD_CTX_destroy(ctx);
 106
 107      if (!endvhdr_found) {
 108          logn(LOGERR, _("broken index"));
 109 @@ -251,22 +253,24 @@ static
 110  int digest(tn_stream *st, unsigned char *md, int *md_size, EVP_MD_CTX *_ctx)
 111  {
 112      unsigned char buf[16*1024];
 113 -    EVP_MD_CTX ctx;
 114 +    EVP_MD_CTX *ctx;
 115      int n, nn = 0;
 116
 117
 118      n_assert(md_size && *md_size);
 119
 120 -    EVP_DigestInit(&ctx, EVP_sha1());
 121 +    ctx = EVP_MD_CTX_create();
 122 +    EVP_DigestInit(ctx, EVP_sha1());
 123
 124      while ((n = n_stream_read(st, buf, sizeof(buf))) > 0) {
 125 -        EVP_DigestUpdate(&ctx, buf, n);
 126 +        EVP_DigestUpdate(ctx, buf, n);
 127          if (_ctx)
 128              EVP_DigestUpdate(_ctx, buf, n);
 129          nn += n;
 130      }
 131
 132 -    EVP_DigestFinal(&ctx, buf, &n);
 133 +    EVP_DigestFinal(ctx, buf, &n);
 134 +    EVP_MD_CTX_destroy(ctx);
 135
 136      if (n > *md_size) {
 137          *md = '\0';
 138 @@ -288,7 +292,7 @@ int pdir_digest_calc(struct pdir_digest
 139      unsigned char   mdh[64], mdd[64], md[64], mdhex[64];
 140      int             mdh_size = sizeof(mdh), mdd_size = sizeof(mdd),
 141                      md_size = sizeof(md);
 142 -    EVP_MD_CTX      ctx, *ctxp;
 143 +    EVP_MD_CTX      *ctx, *ctxp;
 144      int             is_err = 0, n;
 145
 146
 147 @@ -300,27 +304,34 @@ int pdir_digest_calc(struct pdir_digest
 148
 149      ctxp = NULL;
 150      if (flags & CALC_MD) {
 151 -        EVP_DigestInit(&ctx, EVP_sha1());
 152 -        ctxp = &ctx;
 153 +        ctx = EVP_MD_CTX_create();
 154 +        EVP_DigestInit(ctx, EVP_sha1());
 155 +        ctxp = ctx;
 156      }
 157
 158      if ((flags & CALC_MDD) == 0) { /* no separate header && body digests */
 159          if (!digest(st, mdd, &mdd_size, ctxp)) {
 160 -            if (ctxp)
 161 -                EVP_DigestFinal(&ctx, md, &md_size);
 162 +            if (ctxp) {
 163 +                EVP_DigestFinal(ctx, md, &md_size);
 164 +                EVP_MD_CTX_destroy(ctx);
 165 +            }
 166              return 0;
 167          }
 168
 169      } else {
 170          if (!hdr_digest(st, mdh, &mdh_size, ctxp)) {
 171 -            if (ctxp)
 172 -                EVP_DigestFinal(&ctx, md, &md_size);
 173 +            if (ctxp) {
 174 +                EVP_DigestFinal(ctx, md, &md_size);
 175 +                EVP_MD_CTX_destroy(ctx);
 176 +            }
 177              return 0;
 178          }
 179
 180          if (!digest(st, mdd, &mdd_size, ctxp)) {
 181 -            if (ctxp)
 182 -                EVP_DigestFinal(&ctx, md, &md_size);
 183 +            if (ctxp) {
 184 +                EVP_DigestFinal(ctx, md, &md_size);
 185 +                EVP_MD_CTX_destroy(ctx);
 186 +            }
 187              return 0;
 188          }
 189      }
 190 @@ -336,7 +347,8 @@ int pdir_digest_calc(struct pdir_digest
 191      }
 192
 193      if (ctxp) {
 194 -        EVP_DigestFinal(&ctx, md, &md_size);
 195 +        EVP_DigestFinal(ctx, md, &md_size);
 196 +        EVP_MD_CTX_destroy(ctx);
 197          n = bin2hex(mdhex, sizeof(mdhex), md, md_size);
 198          if (n != PDIR_DIGEST_SIZE)
 199              is_err = 1;
 200 --- poldek-0.32.2/pkgdir/pndir/digest.c~        2016-01-30 15:05:57.000000000 +0100
 201 +++ poldek-0.32.2/pkgdir/pndir/digest.c 2018-09-14 18:53:40.521640846 +0200
 202 @@ -241,12 +241,13 @@ int pndir_digest_calc_pkgs(struct pndir_
 203  int pndir_digest_calc(struct pndir_digest *pdg, tn_array *keys)
 204  {
 205      unsigned char md[256];
 206 -    EVP_MD_CTX ctx;
 207 +    EVP_MD_CTX *ctx;
 208      int i, n, nn = 0;
 209
 210
 211 -    EVP_DigestInit(&ctx, EVP_sha1());
 212 -    EVP_DigestUpdate(&ctx, "md", strlen("md"));
 213 +    ctx = EVP_MD_CTX_create();
 214 +    EVP_DigestInit(ctx, EVP_sha1());
 215 +    EVP_DigestUpdate(ctx, "md", strlen("md"));
 216
 217      if (keys && n_array_size(keys)) {
 218          n_array_sort(keys);
 219 @@ -254,11 +255,12 @@ int pndir_digest_calc(struct pndir_diges
 220          for (i=0; i < n_array_size(keys); i++) {
 221              char *key = n_array_nth(keys, i);
 222              DBGF("key = %s\n", key);
 223 -            EVP_DigestUpdate(&ctx, key, strlen(key));
 224 +            EVP_DigestUpdate(ctx, key, strlen(key));
 225          }
 226      }
 227
 228 -    EVP_DigestFinal(&ctx, md, &n);
 229 +    EVP_DigestFinal(ctx, md, &n);
 230 +    EVP_MD_CTX_destroy(ctx);
 231
 232      if (n > (int)sizeof(pdg->md))
 233          return 0;
 234 --- poldek-0.32.2/misc.c~       2016-01-30 15:05:57.000000000 +0100
 235 +++ poldek-0.32.2/misc.c        2018-09-14 18:55:01.440752874 +0200
 236 @@ -80,23 +80,25 @@ static
 237  int mdigest(FILE *stream, unsigned char *md, unsigned *md_size, int digest_type)
 238  {
 239      unsigned char buf[8*1024];
 240 -    EVP_MD_CTX ctx;
 241 +    EVP_MD_CTX *ctx;
 242      unsigned n, nn = 0;
 243
 244
 245      n_assert(md_size && *md_size);
 246
 247 +    ctx = EVP_MD_CTX_create();
 248      if (digest_type == DIGEST_MD5)
 249 -        EVP_DigestInit(&ctx, EVP_md5());
 250 +        EVP_DigestInit(ctx, EVP_md5());
 251      else
 252 -        EVP_DigestInit(&ctx, EVP_sha1());
 253 +        EVP_DigestInit(ctx, EVP_sha1());
 254
 255      while ((n = fread(buf, 1, sizeof(buf), stream)) > 0) {
 256 -        EVP_DigestUpdate(&ctx, buf, n);
 257 +        EVP_DigestUpdate(ctx, buf, n);
 258          nn += n;
 259      }
 260
 261 -    EVP_DigestFinal(&ctx, buf, &n);
 262 +    EVP_DigestFinal(ctx, buf, &n);
 263 +    EVP_MD_CTX_destroy(ctx);
 264
 265      if (n > *md_size) {
 266          *md = '\0';