← Back to branch summary

~ubuntu-branches/ubuntu/raring/gnupg2/raring-updates

« back to all changes in this revision

Viewing changes to g10/keyid.c

  • Committer: Package Import Robot
  • Author(s): Sebastien Bacher
  • Date: 2012-11-06 11:25:58 UTC
  • mfrom: (1.1.16) (7.1.8 raring-proposed)
  • Revision ID: package-import@ubuntu.com-20121106112558-lkpndvv4gqthgrn4
Tags: 2.0.19-1ubuntu1
* Resynchronize on Debian, remaining changes:
  - Add udev rules to give gpg access to some smartcard readers;
    Debian #543217.
    . debian/gnupg2.dev: udev rules to set ACLs on SCM smartcard readers.

Show diffs side-by-side

added added

removed removed

Lines of Context:
g10/keyid.c
45
45
      case PUBKEY_ALGO_ELGAMAL_E: return 'g';
46
46
      case PUBKEY_ALGO_ELGAMAL: return 'G' ;
47
47
      case PUBKEY_ALGO_DSA:     return 'D' ;
 
48
      case PUBKEY_ALGO_ECDSA:   return 'E' ;    /* ECC DSA (sign only)   */
 
49
      case PUBKEY_ALGO_ECDH:    return 'e' ;    /* ECC DH (encrypt only) */
48
50
      default: return '?';
49
51
    }
50
52
}
102
104
      u16 days=0;
103
105
      if(pk->expiredate)
104
106
        days=(u16)((pk->expiredate - pk->timestamp) / 86400L);
105
 
 
 
107
 
106
108
      gcry_md_putc ( md, days >> 8 );
107
109
      gcry_md_putc ( md, days );
108
110
    }
170
172
    BUG ();
171
173
  if (nbytes < 8) /* oops */
172
174
    ki[0] = ki[1] = 0;
173
 
  else 
 
175
  else
174
176
    {
175
177
      p = buffer + nbytes - 8;
176
178
      ki[0] = (p[0] << 24) | (p[1] <<16) | (p[2] << 8) | p[3];
206
208
 
207
209
const char *
208
210
keystr(u32 *keyid)
209
 
{  
 
211
{
210
212
  static char keyid_str[19];
211
213
 
212
214
  switch(opt.keyid_format)
452
454
  if (!uid->namehash)
453
455
    {
454
456
      uid->namehash = xmalloc (20);
455
 
      
 
457
 
456
458
      if(uid->attrib_data)
457
459
        rmd160_hash_buffer (uid->namehash, uid->attrib_data, uid->attrib_len);
458
460
      else
459
461
        rmd160_hash_buffer (uid->namehash, uid->name, uid->len);
460
462
    }
461
 
  
 
463
 
462
464
  return uid->namehash;
463
465
}
464
466
 
636
638
colon_datestr_from_sig (PKT_signature *sig)
637
639
{
638
640
  static char buf[20];
639
 
  
 
641
 
640
642
  snprintf (buf, sizeof buf, "%lu", (ulong)sig->timestamp);
641
643
  return buf;
642
644
}
667
669
  const byte *dp;
668
670
  size_t len, nbytes;
669
671
  int i;
670
 
  
 
672
 
671
673
  if ( pk->version < 4 )
672
674
    {
673
675
      if ( is_RSA(pk->pubkey_algo) )
674
676
        {
675
677
          /* RSA in version 3 packets is special. */
676
678
          gcry_md_hd_t md;
677
 
          
 
679
 
678
680
          if (gcry_md_open (&md, DIGEST_ALGO_MD5, 0))
679
681
            BUG ();
680
 
          if ( pubkey_get_npkey (pk->pubkey_algo) > 1 ) 
 
682
          if ( pubkey_get_npkey (pk->pubkey_algo) > 1 )
681
683
            {
682
684
              for (i=0; i < 2; i++)
683
685
                {
684
 
                  if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, 
 
686
                  if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0,
685
687
                                      &nbytes, pk->pkey[i]))
686
688
                    BUG ();
687
689
                  /* fixme: Better allocate BUF on the stack */
708
710
          memset (array,0,16);
709
711
        }
710
712
    }
711
 
  else 
 
713
  else
712
714
    {
713
715
      gcry_md_hd_t md;
714
 
      
 
716
 
715
717
      md = do_fingerprint_md(pk);
716
718
      dp = gcry_md_read( md, 0 );
717
719
      len = gcry_md_get_algo_dlen (gcry_md_get_algo (md));
723
725
      pk->keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
724
726
      gcry_md_close( md);
725
727
    }
726
 
  
 
728
 
727
729
  *ret_len = len;
728
730
  return array;
729
731
}
735
737
  const char *dp;
736
738
  size_t len, nbytes;
737
739
  int i;
738
 
  
 
740
 
739
741
  if (sk->version < 4)
740
742
    {
741
743
      if ( is_RSA(sk->pubkey_algo) )
742
744
        {
743
745
          /* RSA in version 3 packets is special. */
744
746
          gcry_md_hd_t md;
745
 
          
 
747
 
746
748
          if (gcry_md_open (&md, DIGEST_ALGO_MD5, 0))
747
749
            BUG ();
748
750
          if (pubkey_get_npkey( sk->pubkey_algo ) > 1)
749
751
            {
750
752
              for (i=0; i < 2; i++)
751
753
                {
752
 
                  if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, 
 
754
                  if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0,
753
755
                                      &nbytes, sk->skey[i]))
754
756
                    BUG ();
755
757
                  /* fixme: Better allocate BUF on the stack */
779
781
  else
780
782
    {
781
783
      gcry_md_hd_t md;
782
 
      
 
784
 
783
785
      md = do_fingerprint_md_sk(sk);
784
786
      if (md)
785
787
        {
799
801
          memset (array, 0, len);
800
802
        }
801
803
    }
802
 
  
 
804
 
803
805
  *ret_len = len;
804
806
  return array;
805
807
}
816
818
  size_t fprlen;
817
819
  char *buffer, *p;
818
820
  int i;
819
 
  
 
821
 
820
822
  fingerprint_from_sk (sk, fpr, &fprlen);
821
823
  buffer = p = xmalloc (snlen*2 + 1 + fprlen*2 + 1);
822
824
  for (i=0; i < snlen; i++, p+=2)
827
829
  *p = 0;
828
830
  return buffer;
829
831
}
830