pgpmicalg.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include "mutt/lib.h"
#include "core/lib.h"
#include "pgpmicalg.h"
#include "handler.h"
#include "pgppacket.h"
 
struct HashAlgorithm
{
  short id;         
  const char *name; 
};
 
static const struct HashAlgorithm HashAlgorithms[] = {
  { 1, "pgp-md5" },     { 2, "pgp-sha1" },     { 3, "pgp-ripemd160" },
  { 5, "pgp-md2" },     { 6, "pgp-tiger192" }, { 7, "pgp-haval-5-160" },
  { 8, "pgp-sha256" },  { 9, "pgp-sha384" },   { 10, "pgp-sha512" },
  { 11, "pgp-sha224" }, { -1, NULL },
};
 
static const char *pgp_hash_to_micalg(short id)
{
  for (int i = 0; HashAlgorithms[i].id >= 0; i++)
    if (HashAlgorithms[i].id == id)
      return HashAlgorithms[i].name;
  return "x-unknown";
}
 
static void pgp_dearmor(FILE *fp_in, FILE *fp_out)
{
  char line[8192] = { 0 };
  char *r = NULL;
 
  struct State state = { 0 };
  state.fp_in = fp_in;
  state.fp_out = fp_out;
 
  /* find the beginning of ASCII armor */
 
  while ((r = fgets(line, sizeof(line), fp_in)))
  {
    if (mutt_strn_equal(line, "-----BEGIN", 10))
      break;
  }
  if (!r)
  {
    mutt_debug(LL_DEBUG1, "Can't find begin of ASCII armor\n");
    return;
  }
 
  /* skip the armor header */
 
  while ((r = fgets(line, sizeof(line), fp_in)))
  {
    SKIPWS(r);
    if (*r == '\0')
      break;
  }
  if (!r)
  {
    mutt_debug(LL_DEBUG1, "Armor header doesn't end\n");
    return;
  }
 
  /* actual data starts here */
  LOFF_T start = ftello(fp_in);
  if (start < 0)
    return;
 
  /* find the checksum */
 
  while ((r = fgets(line, sizeof(line), fp_in)))
  {
    if ((*line == '=') || mutt_strn_equal(line, "-----END", 8))
      break;
  }
  if (!r)
  {
    mutt_debug(LL_DEBUG1, "Can't find end of ASCII armor\n");
    return;
  }
 
  LOFF_T end = ftello(fp_in) - strlen(line);
  if (end < start)
  {
    mutt_debug(LL_DEBUG1, "end < start???\n");
    return;
  }
 
  if (!mutt_file_seek(fp_in, start, SEEK_SET))
  {
    return;
  }
 
  mutt_decode_base64(&state, end - start, false, ICONV_T_INVALID);
}
 
static short pgp_mic_from_packet(unsigned char *p, size_t len)
{
  /* is signature? */
  if ((p[0] & 0x3f) != PT_SIG)
  {
    mutt_debug(LL_DEBUG1, "tag = %d, want %d\n", p[0] & 0x3f, PT_SIG);
    return -1;
  }
 
  if ((len >= 18) && (p[1] == 3))
  {
    /* version 3 signature */
    return (short) p[17];
  }
  else if ((len >= 5) && (p[1] == 4))
  {
    /* version 4 signature */
    return (short) p[4];
  }
  else
  {
    mutt_debug(LL_DEBUG1, "Bad signature packet\n");
    return -1;
  }
}
 
static short pgp_find_hash(const char *fname)
{
  size_t l;
  short rc = -1;
 
  FILE *fp_in = NULL;
  FILE *fp_out = mutt_file_mkstemp();
  if (!fp_out)
  {
    mutt_perror(_("Can't create temporary file"));
    goto bye;
  }
 
  fp_in = mutt_file_fopen(fname, "r");
  if (!fp_in)
  {
    mutt_perror("%s", fname);
    goto bye;
  }
 
  pgp_dearmor(fp_in, fp_out);
  rewind(fp_out);
 
  unsigned char *p = pgp_read_packet(fp_out, &l);
  if (p)
  {
    rc = pgp_mic_from_packet(p, l);
  }
  else
  {
    mutt_debug(LL_DEBUG1, "No packet\n");
  }
 
bye:
  mutt_file_fclose(&fp_in);
  mutt_file_fclose(&fp_out);
  pgp_release_packet();
  return rc;
}
 
const char *pgp_micalg(const char *fname)
{
  return pgp_hash_to_micalg(pgp_find_hash(fname));
}