Merge branch 'fix-https-noproxy' of github.com:patcable/apt

[apt.git] / methods / gpgv.cc

diff --git a/methods/gpgv.cc b/methods/gpgv.cc
index 70207e6150ff52061ed47e9e23a021aaa8ab83e8..60a7d4719a07ee43ec75bd2dfae8cc6e2d6a54f0 100644 (file)
--- a/methods/gpgv.cc
+++ b/methods/gpgv.cc
@@ -32,6 +32,7 @@ using std::vector;
 
 #define GNUPGPREFIX "[GNUPG:]"
 #define GNUPGBADSIG "[GNUPG:] BADSIG"
 
 #define GNUPGPREFIX "[GNUPG:]"
 #define GNUPGBADSIG "[GNUPG:] BADSIG"

+#define GNUPGERRSIG "[GNUPG:] ERRSIG"

 #define GNUPGNOPUBKEY "[GNUPG:] NO_PUBKEY"
 #define GNUPGVALIDSIG "[GNUPG:] VALIDSIG"
 #define GNUPGGOODSIG "[GNUPG:] GOODSIG"
 #define GNUPGNOPUBKEY "[GNUPG:] NO_PUBKEY"
 #define GNUPGVALIDSIG "[GNUPG:] VALIDSIG"
 #define GNUPGGOODSIG "[GNUPG:] GOODSIG"


@@ -46,6 +47,19 @@ struct Digest {
       Trusted,
    } state;
    char name[32];
       Trusted,
    } state;
    char name[32];

+
+   State getState() const {
+      std::string optionUntrusted;
+      std::string optionWeak;
+      strprintf(optionUntrusted, "APT::Hashes::%s::Untrusted", name);
+      strprintf(optionWeak, "APT::Hashes::%s::Weak", name);
+      if (_config->FindB(optionUntrusted, state == State::Untrusted) == true)
+        return State::Untrusted;
+      if (_config->FindB(optionWeak, state == State::Weak) == true)
+        return State::Weak;
+
+      return state;
+   }

 };
 
 static constexpr Digest Digests[] = {
 };
 
 static constexpr Digest Digests[] = {


@@ -77,6 +91,10 @@ struct Signer {
    std::string key;
    std::string note;
 };
    std::string key;
    std::string note;
 };

+static bool IsTheSameKey(std::string const &validsig, std::string const &goodsig) {
+   // VALIDSIG reports a keyid (40 = 24 + 16), GOODSIG is a longid (16) only
+   return validsig.compare(24, 16, goodsig, strlen("GOODSIG "), 16) == 0;
+}

 
 class GPGVMethod : public aptMethod
 {
 
 class GPGVMethod : public aptMethod
 {


@@ -91,7 +109,6 @@ class GPGVMethod : public aptMethod
    protected:
    virtual bool URIAcquire(std::string const &Message, FetchItem *Itm) APT_OVERRIDE;
    public:
    protected:
    virtual bool URIAcquire(std::string const &Message, FetchItem *Itm) APT_OVERRIDE;
    public:

-   

    GPGVMethod() : aptMethod("gpgv","1.0",SingleInstance | SendConfig) {};
 };
 
    GPGVMethod() : aptMethod("gpgv","1.0",SingleInstance | SendConfig) {};
 };
 


@@ -125,6 +142,7 @@ string GPGVMethod::VerifyGetSigners(const char *file, const char *outfile,
 
    // Loop over the output of apt-key (which really is gnupg), and check the signatures.
    std::vector<std::string> ValidSigners;
 
    // Loop over the output of apt-key (which really is gnupg), and check the signatures.
    std::vector<std::string> ValidSigners;

+   std::vector<std::string> ErrSigners;

    size_t buffersize = 0;
    char *buffer = NULL;
    while (1)
    size_t buffersize = 0;
    char *buffer = NULL;
    while (1)


@@ -144,11 +162,19 @@ string GPGVMethod::VerifyGetSigners(const char *file, const char *outfile,
             std::clog << "Got BADSIG! " << std::endl;
          BadSigners.push_back(string(buffer+sizeof(GNUPGPREFIX)));
       }
             std::clog << "Got BADSIG! " << std::endl;
          BadSigners.push_back(string(buffer+sizeof(GNUPGPREFIX)));
       }

+      else if (strncmp(buffer, GNUPGERRSIG, sizeof(GNUPGERRSIG)-1) == 0)
+      {
+         if (Debug == true)
+            std::clog << "Got ERRSIG " << std::endl;
+         ErrSigners.push_back(string(buffer, strlen(GNUPGPREFIX), strlen("ERRSIG ") + 16));
+      }

       else if (strncmp(buffer, GNUPGNOPUBKEY, sizeof(GNUPGNOPUBKEY)-1) == 0)
       {
          if (Debug == true)
             std::clog << "Got NO_PUBKEY " << std::endl;
          NoPubKeySigners.push_back(string(buffer+sizeof(GNUPGPREFIX)));
       else if (strncmp(buffer, GNUPGNOPUBKEY, sizeof(GNUPGNOPUBKEY)-1) == 0)
       {
          if (Debug == true)
             std::clog << "Got NO_PUBKEY " << std::endl;
          NoPubKeySigners.push_back(string(buffer+sizeof(GNUPGPREFIX)));

+        ErrSigners.erase(std::remove_if(ErrSigners.begin(), ErrSigners.end(), [&](std::string const &errsig) {
+                 return errsig.compare(strlen("ERRSIG "), 16, buffer, strlen(GNUPGNOPUBKEY), 16) == 0;  }), ErrSigners.end());

       }
       else if (strncmp(buffer, GNUPGNODATA, sizeof(GNUPGBADSIG)-1) == 0)
       {
       }
       else if (strncmp(buffer, GNUPGNODATA, sizeof(GNUPGBADSIG)-1) == 0)
       {


@@ -189,23 +215,29 @@ string GPGVMethod::VerifyGetSigners(const char *file, const char *outfile,
          while (*p && isxdigit(*p))
             p++;
          *p = 0;
          while (*p && isxdigit(*p))
             p++;
          *p = 0;

-         if (Debug == true)
-            std::clog << "Got VALIDSIG, key ID: " << sig << std::endl;

          // Reject weak digest algorithms
          Digest digest = FindDigest(tokens[7]);
          // Reject weak digest algorithms
          Digest digest = FindDigest(tokens[7]);

-         switch (digest.state) {
+         switch (digest.getState()) {

          case Digest::State::Weak:
             // Treat them like an expired key: For that a message about expiry
             // is emitted, a VALIDSIG, but no GOODSIG.
             SoonWorthlessSigners.push_back({string(sig), digest.name});
          case Digest::State::Weak:
             // Treat them like an expired key: For that a message about expiry
             // is emitted, a VALIDSIG, but no GOODSIG.
             SoonWorthlessSigners.push_back({string(sig), digest.name});

+           if (Debug == true)
+              std::clog << "Got weak VALIDSIG, key ID: " << sig << std::endl;

             break;
          case Digest::State::Untrusted:
             // Treat them like an expired key: For that a message about expiry
             // is emitted, a VALIDSIG, but no GOODSIG.
             WorthlessSigners.push_back(string(sig));
             break;
          case Digest::State::Untrusted:
             // Treat them like an expired key: For that a message about expiry
             // is emitted, a VALIDSIG, but no GOODSIG.
             WorthlessSigners.push_back(string(sig));

-            GoodSigners.erase(std::remove(GoodSigners.begin(), GoodSigners.end(), string(sig)));
+            GoodSigners.erase(std::remove_if(GoodSigners.begin(), GoodSigners.end(), [&](std::string const &goodsig) {
+                    return IsTheSameKey(string(sig), goodsig); }), GoodSigners.end());
+           if (Debug == true)
+              std::clog << "Got untrusted VALIDSIG, key ID: " << sig << std::endl;

             break;
             break;

-         case Digest::State::Trusted:
+
+        case Digest::State::Trusted:
+           if (Debug == true)
+              std::clog << "Got trusted VALIDSIG, key ID: " << sig << std::endl;

             break;
          }
 
             break;
          }
 


@@ -214,6 +246,7 @@ string GPGVMethod::VerifyGetSigners(const char *file, const char *outfile,
    }
    fclose(pipein);
    free(buffer);
    }
    fclose(pipein);
    free(buffer);

+   std::move(ErrSigners.begin(), ErrSigners.end(), std::back_inserter(WorthlessSigners));

 
    // apt-key has a --keyid parameter, but this requires gpg, so we call it without it
    // and instead check after the fact which keyids where used for verification
 
    // apt-key has a --keyid parameter, but this requires gpg, so we call it without it
    // and instead check after the fact which keyids where used for verification


@@ -248,7 +281,22 @@ string GPGVMethod::VerifyGetSigners(const char *file, const char *outfile,
    {
       ioprintf(std::clog, "gpgv exited with status %i\n", WEXITSTATUS(status));
    }
    {
       ioprintf(std::clog, "gpgv exited with status %i\n", WEXITSTATUS(status));
    }

-   
+
+   if (Debug)
+   {
+      std::cerr << "Summary:" << std::endl << "  Good: ";
+      std::copy(GoodSigners.begin(), GoodSigners.end(), std::ostream_iterator<std::string>(std::cerr, ", "));
+      std::cerr << std::endl << "  Bad: ";
+      std::copy(BadSigners.begin(), BadSigners.end(), std::ostream_iterator<std::string>(std::cerr, ", "));
+      std::cerr << std::endl << "  Worthless: ";
+      std::copy(WorthlessSigners.begin(), WorthlessSigners.end(), std::ostream_iterator<std::string>(std::cerr, ", "));
+      std::cerr << std::endl << "  SoonWorthless: ";
+      std::for_each(SoonWorthlessSigners.begin(), SoonWorthlessSigners.end(), [](Signer const &sig) { std::cerr << sig.key << ", "; });
+      std::cerr << std::endl << "  NoPubKey: ";
+      std::copy(NoPubKeySigners.begin(), NoPubKeySigners.end(), std::ostream_iterator<std::string>(std::cerr, ", "));
+      std::cerr << std::endl;
+   }
+

    if (WEXITSTATUS(status) == 0)
    {
       if (keyIsID)
    if (WEXITSTATUS(status) == 0)
    {
       if (keyIsID)


@@ -302,13 +350,13 @@ bool GPGVMethod::URIAcquire(std::string const &Message, FetchItem *Itm)
                                  GoodSigners, BadSigners, WorthlessSigners,
                                  SoonWorthlessSigners, NoPubKeySigners);
 
                                  GoodSigners, BadSigners, WorthlessSigners,
                                  SoonWorthlessSigners, NoPubKeySigners);
 

-
-   // Check if there are any good signers that are not soon worthless
-   std::vector<std::string> NotWarnAboutSigners(GoodSigners);
-   for (auto const & Signer : SoonWorthlessSigners)
-      NotWarnAboutSigners.erase(std::remove(NotWarnAboutSigners.begin(), NotWarnAboutSigners.end(), "GOODSIG " + Signer.key));
-   // If all signers are soon worthless, report them.
-   if (NotWarnAboutSigners.empty()) {
+   // Check if all good signers are soon worthless and warn in that case
+   if (std::all_of(GoodSigners.begin(), GoodSigners.end(), [&](std::string const &good) {
+           return std::any_of(SoonWorthlessSigners.begin(), SoonWorthlessSigners.end(), [&](Signer const &weak) {
+                 return IsTheSameKey(weak.key, good);
+                 });
+           }))
+   {

       for (auto const & Signer : SoonWorthlessSigners)
          // TRANSLATORS: The second %s is the reason and is untranslated for repository owners.
          Warning(_("Signature by key %s uses weak digest algorithm (%s)"), Signer.key.c_str(), Signer.note.c_str());
       for (auto const & Signer : SoonWorthlessSigners)
          // TRANSLATORS: The second %s is the reason and is untranslated for repository owners.
          Warning(_("Signature by key %s uses weak digest algorithm (%s)"), Signer.key.c_str(), Signer.note.c_str());