From 2f5b615169aef2d9c74bb337af229dee2dce595e Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Fri, 15 Mar 2013 14:17:01 +0100 Subject: * apt-pkg/indexcopy.cc: - rename RunGPGV to ExecGPGV and move it to apt-pkg/contrib/gpgv.cc --- apt-pkg/contrib/gpgv.cc | 138 ++++++++++++++++++++++++++++++++++++++++++++++++ apt-pkg/contrib/gpgv.h | 24 +++++++++ 2 files changed, 162 insertions(+) create mode 100644 apt-pkg/contrib/gpgv.cc create mode 100644 apt-pkg/contrib/gpgv.h (limited to 'apt-pkg/contrib') diff --git a/apt-pkg/contrib/gpgv.cc b/apt-pkg/contrib/gpgv.cc new file mode 100644 index 000000000..9b008dd4f --- /dev/null +++ b/apt-pkg/contrib/gpgv.cc @@ -0,0 +1,138 @@ +// -*- mode: cpp; mode: fold -*- +// Include Files /*{{{*/ +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + /*}}}*/ + +using namespace std; + +// RunGPGV - returns the command needed for verify /*{{{*/ +// --------------------------------------------------------------------- +/* Generating the commandline for calling gpgv is somehow complicated as + we need to add multiple keyrings and user supplied options. */ +bool ExecGPGV(std::string const &File, std::string const &FileGPG, + int const &statusfd, int fd[2]) +{ + if (File == FileGPG) + { + #define SIGMSG "-----BEGIN PGP SIGNED MESSAGE-----\n" + char buffer[sizeof(SIGMSG)]; + FILE* gpg = fopen(File.c_str(), "r"); + if (gpg == NULL) + return _error->Errno("RunGPGV", _("Could not open file %s"), File.c_str()); + char const * const test = fgets(buffer, sizeof(buffer), gpg); + fclose(gpg); + if (test == NULL || strcmp(buffer, SIGMSG) != 0) + return _error->Error(_("File %s doesn't start with a clearsigned message"), File.c_str()); + #undef SIGMSG + } + + + string const gpgvpath = _config->Find("Dir::Bin::gpg", "/usr/bin/gpgv"); + // FIXME: remove support for deprecated APT::GPGV setting + string const trustedFile = _config->Find("APT::GPGV::TrustedKeyring", _config->FindFile("Dir::Etc::Trusted")); + string const trustedPath = _config->FindDir("Dir::Etc::TrustedParts"); + + bool const Debug = _config->FindB("Debug::Acquire::gpgv", false); + + if (Debug == true) + { + std::clog << "gpgv path: " << gpgvpath << std::endl; + std::clog << "Keyring file: " << trustedFile << std::endl; + std::clog << "Keyring path: " << trustedPath << std::endl; + } + + std::vector keyrings; + if (DirectoryExists(trustedPath)) + keyrings = GetListOfFilesInDir(trustedPath, "gpg", false, true); + if (RealFileExists(trustedFile) == true) + keyrings.push_back(trustedFile); + + std::vector Args; + Args.reserve(30); + + if (keyrings.empty() == true) + { + // TRANSLATOR: %s is the trusted keyring parts directory + return _error->Error(_("No keyring installed in %s."), + _config->FindDir("Dir::Etc::TrustedParts").c_str()); + } + + Args.push_back(gpgvpath.c_str()); + Args.push_back("--ignore-time-conflict"); + + if (statusfd != -1) + { + Args.push_back("--status-fd"); + char fd[10]; + snprintf(fd, sizeof(fd), "%i", statusfd); + Args.push_back(fd); + } + + for (vector::const_iterator K = keyrings.begin(); + K != keyrings.end(); ++K) + { + Args.push_back("--keyring"); + Args.push_back(K->c_str()); + } + + Configuration::Item const *Opts; + Opts = _config->Tree("Acquire::gpgv::Options"); + if (Opts != 0) + { + Opts = Opts->Child; + for (; Opts != 0; Opts = Opts->Next) + { + if (Opts->Value.empty() == true) + continue; + Args.push_back(Opts->Value.c_str()); + } + } + + Args.push_back(FileGPG.c_str()); + if (FileGPG != File) + Args.push_back(File.c_str()); + Args.push_back(NULL); + + if (Debug == true) + { + std::clog << "Preparing to exec: " << gpgvpath; + for (std::vector::const_iterator a = Args.begin(); *a != NULL; ++a) + std::clog << " " << *a; + std::clog << std::endl; + } + + if (statusfd != -1) + { + int const nullfd = open("/dev/null", O_RDONLY); + close(fd[0]); + // Redirect output to /dev/null; we read from the status fd + dup2(nullfd, STDOUT_FILENO); + dup2(nullfd, STDERR_FILENO); + // Redirect the pipe to the status fd (3) + dup2(fd[1], statusfd); + + putenv((char *)"LANG="); + putenv((char *)"LC_ALL="); + putenv((char *)"LC_MESSAGES="); + } + + execvp(gpgvpath.c_str(), (char **) &Args[0]); + return true; +} + /*}}}*/ diff --git a/apt-pkg/contrib/gpgv.h b/apt-pkg/contrib/gpgv.h new file mode 100644 index 000000000..c15166c94 --- /dev/null +++ b/apt-pkg/contrib/gpgv.h @@ -0,0 +1,24 @@ +// -*- mode: cpp; mode: fold -*- +// Description /*{{{*/ +/* ###################################################################### + + Helpers to deal with gpgv better and more easily + + ##################################################################### */ + /*}}}*/ +#ifndef CONTRIB_GPGV_H +#define CONTRIB_GPGV_H + +#include + +/** \brief generates and run the command to verify a file with gpgv */ +bool ExecGPGV(std::string const &File, std::string const &FileOut, + int const &statusfd, int fd[2]); + +inline bool ExecGPGV(std::string const &File, std::string const &FileOut, + int const &statusfd = -1) { + int fd[2]; + return ExecGPGV(File, FileOut, statusfd, fd); +} + +#endif -- cgit v1.2.3-70-g09d2 From 99ed26d32226f0dffe5a37fb78c5588f9d9ecfd5 Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Fri, 15 Mar 2013 14:29:46 +0100 Subject: * apt-pkg/contrib/gpgv.cc: - ExecGPGV is a method which should never return, so mark it as such and fix the inconsistency of returning in error cases --- apt-pkg/contrib/gpgv.cc | 22 ++++++++++++++++------ apt-pkg/contrib/gpgv.h | 26 ++++++++++++++++++++------ apt-pkg/indexcopy.h | 6 ++++-- debian/changelog | 3 +++ methods/gpgv.cc | 14 +------------- 5 files changed, 44 insertions(+), 27 deletions(-) (limited to 'apt-pkg/contrib') diff --git a/apt-pkg/contrib/gpgv.cc b/apt-pkg/contrib/gpgv.cc index 9b008dd4f..9760bd21f 100644 --- a/apt-pkg/contrib/gpgv.cc +++ b/apt-pkg/contrib/gpgv.cc @@ -25,20 +25,28 @@ using namespace std; // --------------------------------------------------------------------- /* Generating the commandline for calling gpgv is somehow complicated as we need to add multiple keyrings and user supplied options. */ -bool ExecGPGV(std::string const &File, std::string const &FileGPG, +void ExecGPGV(std::string const &File, std::string const &FileGPG, int const &statusfd, int fd[2]) { + #define EINTERNAL 111 + if (File == FileGPG) { #define SIGMSG "-----BEGIN PGP SIGNED MESSAGE-----\n" char buffer[sizeof(SIGMSG)]; FILE* gpg = fopen(File.c_str(), "r"); if (gpg == NULL) - return _error->Errno("RunGPGV", _("Could not open file %s"), File.c_str()); + { + ioprintf(std::cerr, _("Could not open file %s"), File.c_str()); + exit(EINTERNAL); + } char const * const test = fgets(buffer, sizeof(buffer), gpg); fclose(gpg); if (test == NULL || strcmp(buffer, SIGMSG) != 0) - return _error->Error(_("File %s doesn't start with a clearsigned message"), File.c_str()); + { + ioprintf(std::cerr, _("File %s doesn't start with a clearsigned message"), File.c_str()); + exit(EINTERNAL); + } #undef SIGMSG } @@ -69,8 +77,9 @@ bool ExecGPGV(std::string const &File, std::string const &FileGPG, if (keyrings.empty() == true) { // TRANSLATOR: %s is the trusted keyring parts directory - return _error->Error(_("No keyring installed in %s."), - _config->FindDir("Dir::Etc::TrustedParts").c_str()); + ioprintf(std::cerr, _("No keyring installed in %s."), + _config->FindDir("Dir::Etc::TrustedParts").c_str()); + exit(EINTERNAL); } Args.push_back(gpgvpath.c_str()); @@ -133,6 +142,7 @@ bool ExecGPGV(std::string const &File, std::string const &FileGPG, } execvp(gpgvpath.c_str(), (char **) &Args[0]); - return true; + ioprintf(std::cerr, "Couldn't execute %s to check %s", Args[0], File.c_str()); + exit(EINTERNAL); } /*}}}*/ diff --git a/apt-pkg/contrib/gpgv.h b/apt-pkg/contrib/gpgv.h index c15166c94..8aeea2fb3 100644 --- a/apt-pkg/contrib/gpgv.h +++ b/apt-pkg/contrib/gpgv.h @@ -11,14 +11,28 @@ #include -/** \brief generates and run the command to verify a file with gpgv */ -bool ExecGPGV(std::string const &File, std::string const &FileOut, - int const &statusfd, int fd[2]); +#if __GNUC__ >= 4 + #define APT_noreturn __attribute__ ((noreturn)) +#else + #define APT_noreturn /* no support */ +#endif -inline bool ExecGPGV(std::string const &File, std::string const &FileOut, +/** \brief generates and run the command to verify a file with gpgv + * + * If File and FileSig specify the same file it is assumed that we + * deal with a clear-signed message. + * + * @param File is the message (unsigned or clear-signed) + * @param FileSig is the signature (detached or clear-signed) + */ +void ExecGPGV(std::string const &File, std::string const &FileSig, + int const &statusfd, int fd[2]) APT_noreturn; +inline void ExecGPGV(std::string const &File, std::string const &FileSig, int const &statusfd = -1) { int fd[2]; - return ExecGPGV(File, FileOut, statusfd, fd); -} + ExecGPGV(File, FileSig, statusfd, fd); +}; + +#undef APT_noreturn #endif diff --git a/apt-pkg/indexcopy.h b/apt-pkg/indexcopy.h index 49e724f2f..aa221158e 100644 --- a/apt-pkg/indexcopy.h +++ b/apt-pkg/indexcopy.h @@ -101,11 +101,13 @@ class SigVerify /*{{{*/ __deprecated static bool RunGPGV(std::string const &File, std::string const &FileOut, int const &statusfd, int fd[2]) { - return ExecGPGV(File, FileOut, statusfd, fd); + ExecGPGV(File, FileOut, statusfd, fd); + return false; }; __deprecated static bool RunGPGV(std::string const &File, std::string const &FileOut, int const &statusfd = -1) { - return ExecGPGV(File, FileOut, statusfd); + ExecGPGV(File, FileOut, statusfd); + return false; }; }; /*}}}*/ diff --git a/debian/changelog b/debian/changelog index ac630ad7e..bd4116406 100644 --- a/debian/changelog +++ b/debian/changelog @@ -3,6 +3,9 @@ apt (0.9.7.9) UNRELEASED; urgency=low [ David Kalnischkies ] * apt-pkg/indexcopy.cc: - rename RunGPGV to ExecGPGV and move it to apt-pkg/contrib/gpgv.cc + * apt-pkg/contrib/gpgv.cc: + - ExecGPGV is a method which should never return, so mark it as such + and fix the inconsistency of returning in error cases -- David Kalnischkies Fri, 15 Mar 2013 14:15:43 +0100 diff --git a/methods/gpgv.cc b/methods/gpgv.cc index 98381b845..3f814b9f0 100644 --- a/methods/gpgv.cc +++ b/methods/gpgv.cc @@ -71,19 +71,7 @@ string GPGVMethod::VerifyGetSigners(const char *file, const char *outfile, if (pid < 0) return string("Couldn't spawn new process") + strerror(errno); else if (pid == 0) - { - _error->PushToStack(); - bool const success = ExecGPGV(outfile, file, 3, fd); - if (success == false) - { - string errmsg; - _error->PopMessage(errmsg); - _error->RevertToStack(); - return errmsg; - } - _error->RevertToStack(); - exit(111); - } + ExecGPGV(outfile, file, 3, fd); close(fd[1]); FILE *pipein = fdopen(fd[0], "r"); -- cgit v1.2.3-70-g09d2 From b38bb727530a7e836689ef100b07926522066986 Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Fri, 15 Mar 2013 14:49:05 +0100 Subject: don't close stdout/stderr if it is also the statusfd --- apt-pkg/contrib/gpgv.cc | 21 +++++++++++---------- debian/changelog | 1 + 2 files changed, 12 insertions(+), 10 deletions(-) (limited to 'apt-pkg/contrib') diff --git a/apt-pkg/contrib/gpgv.cc b/apt-pkg/contrib/gpgv.cc index 9760bd21f..94a1f8778 100644 --- a/apt-pkg/contrib/gpgv.cc +++ b/apt-pkg/contrib/gpgv.cc @@ -2,14 +2,13 @@ // Include Files /*{{{*/ #include -#include -#include -#include +#include +#include #include #include #include -#include -#include + +#include #include #include @@ -85,12 +84,12 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, Args.push_back(gpgvpath.c_str()); Args.push_back("--ignore-time-conflict"); + char statusfdstr[10]; if (statusfd != -1) { Args.push_back("--status-fd"); - char fd[10]; - snprintf(fd, sizeof(fd), "%i", statusfd); - Args.push_back(fd); + snprintf(statusfdstr, sizeof(fd), "%i", statusfd); + Args.push_back(statusfdstr); } for (vector::const_iterator K = keyrings.begin(); @@ -131,8 +130,10 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, int const nullfd = open("/dev/null", O_RDONLY); close(fd[0]); // Redirect output to /dev/null; we read from the status fd - dup2(nullfd, STDOUT_FILENO); - dup2(nullfd, STDERR_FILENO); + if (statusfd != STDOUT_FILENO) + dup2(nullfd, STDOUT_FILENO); + if (statusfd != STDERR_FILENO) + dup2(nullfd, STDERR_FILENO); // Redirect the pipe to the status fd (3) dup2(fd[1], statusfd); diff --git a/debian/changelog b/debian/changelog index bd4116406..0423cefa6 100644 --- a/debian/changelog +++ b/debian/changelog @@ -6,6 +6,7 @@ apt (0.9.7.9) UNRELEASED; urgency=low * apt-pkg/contrib/gpgv.cc: - ExecGPGV is a method which should never return, so mark it as such and fix the inconsistency of returning in error cases + - don't close stdout/stderr if it is also the statusfd -- David Kalnischkies Fri, 15 Mar 2013 14:15:43 +0100 -- cgit v1.2.3-70-g09d2 From 4fb400a66f2436cba6c89cecdc9560c9b1c54337 Mon Sep 17 00:00:00 2001 From: Michael Vogt Date: Fri, 15 Mar 2013 14:57:27 +0100 Subject: split out a method to strip whitespaces only on the right side --- apt-pkg/contrib/strutl.cc | 8 +++++++- apt-pkg/contrib/strutl.h | 1 + 2 files changed, 8 insertions(+), 1 deletion(-) (limited to 'apt-pkg/contrib') diff --git a/apt-pkg/contrib/strutl.cc b/apt-pkg/contrib/strutl.cc index ca096d736..9726138a0 100644 --- a/apt-pkg/contrib/strutl.cc +++ b/apt-pkg/contrib/strutl.cc @@ -117,7 +117,13 @@ char *_strstrip(char *String) if (*String == 0) return String; - + return _strrstrip(String); +} + /*}}}*/ +// strrstrip - Remove white space from the back of a string /*{{{*/ +// --------------------------------------------------------------------- +char *_strrstrip(char *String) +{ char *End = String + strlen(String) - 1; for (;End != String - 1 && (*End == ' ' || *End == '\t' || *End == '\n' || *End == '\r'); End--); diff --git a/apt-pkg/contrib/strutl.h b/apt-pkg/contrib/strutl.h index 337139d5d..e92f91dc0 100644 --- a/apt-pkg/contrib/strutl.h +++ b/apt-pkg/contrib/strutl.h @@ -35,6 +35,7 @@ using std::ostream; bool UTF8ToCodeset(const char *codeset, const std::string &orig, std::string *dest); char *_strstrip(char *String); +char *_strrstrip(char *String); // right strip only char *_strtabexpand(char *String,size_t Len); bool ParseQuoteWord(const char *&String,std::string &Res); bool ParseCWord(const char *&String,std::string &Res); -- cgit v1.2.3-70-g09d2 From 2d3fe9cfadb33556b7563a98bb5a4698888e6c40 Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Fri, 15 Mar 2013 18:53:53 +0100 Subject: - if ExecGPGV deals with a clear-signed file it will split this file into data and signatures, pass it to gpgv for verification and recombines it after that in a known-good way without unsigned blocks and whitespaces resulting usually in more or less the same file as before, but later code can be sure about the format * apt-pkg/deb/debmetaindex.cc: - reenable InRelease by default --- apt-pkg/contrib/gpgv.cc | 302 ++++++++++++++++++--- apt-pkg/contrib/gpgv.h | 41 ++- apt-pkg/deb/debmetaindex.cc | 31 ++- debian/changelog | 7 + ...st-ubuntu-bug-784473-InRelease-one-message-only | 14 +- 5 files changed, 337 insertions(+), 58 deletions(-) (limited to 'apt-pkg/contrib') diff --git a/apt-pkg/contrib/gpgv.cc b/apt-pkg/contrib/gpgv.cc index 94a1f8778..c236a7289 100644 --- a/apt-pkg/contrib/gpgv.cc +++ b/apt-pkg/contrib/gpgv.cc @@ -2,58 +2,54 @@ // Include Files /*{{{*/ #include +#include #include +#include #include +#include #include #include -#include - -#include +#include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include /*}}}*/ +char * GenerateTemporaryFileTemplate(const char *basename) /*{{{*/ +{ + const char *tmpdir = getenv("TMPDIR"); +#ifdef P_tmpdir + if (!tmpdir) + tmpdir = P_tmpdir; +#endif + if (!tmpdir) + tmpdir = "/tmp"; -using namespace std; - -// RunGPGV - returns the command needed for verify /*{{{*/ + std::string out; + strprintf(out, "%s/%s.XXXXXX", tmpdir, basename); + return strdup(out.c_str()); +} + /*}}}*/ +// ExecGPGV - returns the command needed for verify /*{{{*/ // --------------------------------------------------------------------- /* Generating the commandline for calling gpgv is somehow complicated as - we need to add multiple keyrings and user supplied options. */ + we need to add multiple keyrings and user supplied options. + Also, as gpgv has no options to enforce a certain reduced style of + clear-signed files (=the complete content of the file is signed and + the content isn't encoded) we do a divide and conquer approach here +*/ void ExecGPGV(std::string const &File, std::string const &FileGPG, - int const &statusfd, int fd[2]) + int const &statusfd, int fd[2]) { #define EINTERNAL 111 - - if (File == FileGPG) - { - #define SIGMSG "-----BEGIN PGP SIGNED MESSAGE-----\n" - char buffer[sizeof(SIGMSG)]; - FILE* gpg = fopen(File.c_str(), "r"); - if (gpg == NULL) - { - ioprintf(std::cerr, _("Could not open file %s"), File.c_str()); - exit(EINTERNAL); - } - char const * const test = fgets(buffer, sizeof(buffer), gpg); - fclose(gpg); - if (test == NULL || strcmp(buffer, SIGMSG) != 0) - { - ioprintf(std::cerr, _("File %s doesn't start with a clearsigned message"), File.c_str()); - exit(EINTERNAL); - } - #undef SIGMSG - } - - - string const gpgvpath = _config->Find("Dir::Bin::gpg", "/usr/bin/gpgv"); + std::string const gpgvpath = _config->Find("Dir::Bin::gpg", "/usr/bin/gpgv"); // FIXME: remove support for deprecated APT::GPGV setting - string const trustedFile = _config->Find("APT::GPGV::TrustedKeyring", _config->FindFile("Dir::Etc::Trusted")); - string const trustedPath = _config->FindDir("Dir::Etc::TrustedParts"); + std::string const trustedFile = _config->Find("APT::GPGV::TrustedKeyring", _config->FindFile("Dir::Etc::Trusted")); + std::string const trustedPath = _config->FindDir("Dir::Etc::TrustedParts"); bool const Debug = _config->FindB("Debug::Acquire::gpgv", false); @@ -64,7 +60,7 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, std::clog << "Keyring path: " << trustedPath << std::endl; } - std::vector keyrings; + std::vector keyrings; if (DirectoryExists(trustedPath)) keyrings = GetListOfFilesInDir(trustedPath, "gpg", false, true); if (RealFileExists(trustedFile) == true) @@ -88,11 +84,11 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, if (statusfd != -1) { Args.push_back("--status-fd"); - snprintf(statusfdstr, sizeof(fd), "%i", statusfd); + snprintf(statusfdstr, sizeof(statusfdstr), "%i", statusfd); Args.push_back(statusfdstr); } - for (vector::const_iterator K = keyrings.begin(); + for (std::vector::const_iterator K = keyrings.begin(); K != keyrings.end(); ++K) { Args.push_back("--keyring"); @@ -112,9 +108,49 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, } } - Args.push_back(FileGPG.c_str()); + int sigFd = -1; + int dataFd = -1; + std::vector dataHeader; + char * sig = NULL; + char * data = NULL; + + // file with detached signature if (FileGPG != File) + { + Args.push_back(FileGPG.c_str()); Args.push_back(File.c_str()); + } + else // clear-signed file + { + sig = GenerateTemporaryFileTemplate("apt.sig"); + data = GenerateTemporaryFileTemplate("apt.data"); + if (sig == NULL || data == NULL) + { + ioprintf(std::cerr, "Couldn't create tempfiles for splitting up %s", File.c_str()); + exit(EINTERNAL); + } + + sigFd = mkstemp(sig); + dataFd = mkstemp(data); + int const duppedSigFd = dup(sigFd); + int const duppedDataFd = dup(dataFd); + + if (dataFd == -1 || sigFd == -1 || duppedDataFd == -1 || duppedSigFd == -1 || + SplitClearSignedFile(File, duppedDataFd, &dataHeader, duppedSigFd) == false) + { + if (dataFd != -1) + unlink(sig); + if (sigFd != -1) + unlink(data); + ioprintf(std::cerr, "Splitting up %s into data and signature failed", File.c_str()); + exit(EINTERNAL); + } + lseek(dataFd, 0, SEEK_SET); + lseek(sigFd, 0, SEEK_SET); + Args.push_back(sig); + Args.push_back(data); + } + Args.push_back(NULL); if (Debug == true) @@ -142,8 +178,186 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, putenv((char *)"LC_MESSAGES="); } - execvp(gpgvpath.c_str(), (char **) &Args[0]); - ioprintf(std::cerr, "Couldn't execute %s to check %s", Args[0], File.c_str()); - exit(EINTERNAL); + if (FileGPG != File) + { + execvp(gpgvpath.c_str(), (char **) &Args[0]); + ioprintf(std::cerr, "Couldn't execute %s to check %s", Args[0], File.c_str()); + exit(EINTERNAL); + } + else + { +//#define UNLINK_EXIT(X) exit(X) +#define UNLINK_EXIT(X) unlink(sig);unlink(data);exit(X) + + // for clear-signed files we have created tempfiles we have to clean up + // and we do an additional check, so fork yet another time … + pid_t pid = ExecFork(); + if(pid < 0) { + ioprintf(std::cerr, "Fork failed for %s to check %s", Args[0], File.c_str()); + UNLINK_EXIT(EINTERNAL); + } + if(pid == 0) + { + if (statusfd != -1) + dup2(fd[1], statusfd); + execvp(gpgvpath.c_str(), (char **) &Args[0]); + ioprintf(std::cerr, "Couldn't execute %s to check %s", Args[0], File.c_str()); + UNLINK_EXIT(EINTERNAL); + } + + // Wait and collect the error code - taken from WaitPid as we need the exact Status + int Status; + while (waitpid(pid,&Status,0) != pid) + { + if (errno == EINTR) + continue; + ioprintf(std::cerr, _("Waited for %s but it wasn't there"), "gpgv"); + UNLINK_EXIT(EINTERNAL); + } + + // check if it exit'ed normally … + if (WIFEXITED(Status) == false) + { + ioprintf(std::cerr, _("Sub-process %s exited unexpectedly"), "gpgv"); + UNLINK_EXIT(EINTERNAL); + } + + // … and with a good exit code + if (WEXITSTATUS(Status) != 0) + { + ioprintf(std::cerr, _("Sub-process %s returned an error code (%u)"), "gpgv", WEXITSTATUS(Status)); + UNLINK_EXIT(WEXITSTATUS(Status)); + } + + /* looks like its fine. Our caller will check the status fd, + but we construct a good-known clear-signed file without garbage + and other non-sense. In a perfect world, we get the same file, + but empty lines, trailing whitespaces and stuff makes it inperfect … */ + if (RecombineToClearSignedFile(File, dataFd, dataHeader, sigFd) == false) + { + _error->DumpErrors(std::cerr); + UNLINK_EXIT(EINTERNAL); + } + + // everything fine, we have a clean file now! + UNLINK_EXIT(0); +#undef UNLINK_EXIT + } + exit(EINTERNAL); // unreachable safe-guard +} + /*}}}*/ +// RecombineToClearSignedFile - combine data/signature to message /*{{{*/ +bool RecombineToClearSignedFile(std::string const &OutFile, int const ContentFile, + std::vector const &ContentHeader, int const SignatureFile) +{ + FILE *clean_file = fopen(OutFile.c_str(), "w"); + fputs("-----BEGIN PGP SIGNED MESSAGE-----\n", clean_file); + for (std::vector::const_iterator h = ContentHeader.begin(); h != ContentHeader.end(); ++h) + fprintf(clean_file, "%s\n", h->c_str()); + fputs("\n", clean_file); + + FILE *data_file = fdopen(ContentFile, "r"); + FILE *sig_file = fdopen(SignatureFile, "r"); + if (data_file == NULL || sig_file == NULL) + return _error->Error("Couldn't open splitfiles to recombine them into %s", OutFile.c_str()); + char *buf = NULL; + size_t buf_size = 0; + while (getline(&buf, &buf_size, data_file) != -1) + fputs(buf, clean_file); + fclose(data_file); + fputs("\n", clean_file); + while (getline(&buf, &buf_size, sig_file) != -1) + fputs(buf, clean_file); + fclose(sig_file); + fclose(clean_file); + return true; } /*}}}*/ +// SplitClearSignedFile - split message into data/signature /*{{{*/ +bool SplitClearSignedFile(std::string const &InFile, int const ContentFile, + std::vector * const ContentHeader, int const SignatureFile) +{ + FILE *in = fopen(InFile.c_str(), "r"); + if (in == NULL) + return _error->Errno("fopen", "can not open %s", InFile.c_str()); + + FILE *out_content = NULL; + FILE *out_signature = NULL; + if (ContentFile != -1) + { + out_content = fdopen(ContentFile, "w"); + if (out_content == NULL) + return _error->Errno("fdopen", "Failed to open file to write content to from %s", InFile.c_str()); + } + if (SignatureFile != -1) + { + out_signature = fdopen(SignatureFile, "w"); + if (out_signature == NULL) + return _error->Errno("fdopen", "Failed to open file to write signature to from %s", InFile.c_str()); + } + + bool found_message_start = false; + bool found_message_end = false; + bool skip_until_empty_line = false; + bool found_signature = false; + bool first_line = true; + + char *buf = NULL; + size_t buf_size = 0; + while (getline(&buf, &buf_size, in) != -1) + { + _strrstrip(buf); + if (found_message_start == false) + { + if (strcmp(buf, "-----BEGIN PGP SIGNED MESSAGE-----") == 0) + { + found_message_start = true; + skip_until_empty_line = true; + } + } + else if (skip_until_empty_line == true) + { + if (strlen(buf) == 0) + skip_until_empty_line = false; + // save "Hash" Armor Headers, others aren't allowed + else if (ContentHeader != NULL && strncmp(buf, "Hash: ", strlen("Hash: ")) == 0) + ContentHeader->push_back(buf); + } + else if (found_signature == false) + { + if (strcmp(buf, "-----BEGIN PGP SIGNATURE-----") == 0) + { + found_signature = true; + found_message_end = true; + if (out_signature != NULL) + fprintf(out_signature, "%s\n", buf); + } + else if (found_message_end == false) + { + // we are in the message block + if(first_line == true) // first line does not need a newline + { + if (out_content != NULL) + fprintf(out_content, "%s", buf); + first_line = false; + } + else if (out_content != NULL) + fprintf(out_content, "\n%s", buf); + } + } + else if (found_signature == true) + { + if (out_signature != NULL) + fprintf(out_signature, "%s\n", buf); + if (strcmp(buf, "-----END PGP SIGNATURE-----") == 0) + found_signature = false; // look for other signatures + } + // all the rest is whitespace, unsigned garbage or additional message blocks we ignore + } + if (out_content != NULL) + fclose(out_content); + if (out_signature != NULL) + fclose(out_signature); + + return true; +} diff --git a/apt-pkg/contrib/gpgv.h b/apt-pkg/contrib/gpgv.h index 8aeea2fb3..8e04855e4 100644 --- a/apt-pkg/contrib/gpgv.h +++ b/apt-pkg/contrib/gpgv.h @@ -10,6 +10,7 @@ #define CONTRIB_GPGV_H #include +#include #if __GNUC__ >= 4 #define APT_noreturn __attribute__ ((noreturn)) @@ -20,7 +21,9 @@ /** \brief generates and run the command to verify a file with gpgv * * If File and FileSig specify the same file it is assumed that we - * deal with a clear-signed message. + * deal with a clear-signed message. In that case the file will be + * rewritten to be in a good-known format without uneeded whitespaces + * and additional messages (unsigned or signed). * * @param File is the message (unsigned or clear-signed) * @param FileSig is the signature (detached or clear-signed) @@ -35,4 +38,40 @@ inline void ExecGPGV(std::string const &File, std::string const &FileSig, #undef APT_noreturn +/** \brief Split an inline signature into message and signature + * + * Takes a clear-signed message and puts the first signed message + * in the content file and all signatures following it into the + * second. Unsigned messages, additional messages as well as + * whitespaces are discarded. The resulting files are suitable to + * be checked with gpgv. + * + * If one or all Fds are -1 they will not be used and the content + * which would have been written to them is discarded. + * + * The code doesn't support dash-encoded lines as these are not + * expected to be present in files we have to deal with. + * + * @param InFile is the clear-signed file + * @param ContentFile is the Fd the message will be written to + * @param ContentHeader is a list of all required Amored Headers for the message + * @param SignatureFile is the Fd all signatures will be written to + */ +bool SplitClearSignedFile(std::string const &InFile, int const ContentFile, + std::vector * const ContentHeader, int const SignatureFile); + +/** \brief recombines message and signature to an inline signature + * + * Reverses the splitting down by #SplitClearSignedFile by writing + * a well-formed clear-signed message without unsigned messages, + * additional signed messages or just trailing whitespaces + * + * @param OutFile will be clear-signed file + * @param ContentFile is the Fd the message will be read from + * @param ContentHeader is a list of all required Amored Headers for the message + * @param SignatureFile is the Fd all signatures will be read from + */ +bool RecombineToClearSignedFile(std::string const &OutFile, int const ContentFile, + std::vector const &ContentHeader, int const SignatureFile); + #endif diff --git a/apt-pkg/deb/debmetaindex.cc b/apt-pkg/deb/debmetaindex.cc index 6c191fd95..7a88d71e3 100644 --- a/apt-pkg/deb/debmetaindex.cc +++ b/apt-pkg/deb/debmetaindex.cc @@ -229,6 +229,8 @@ vector * debReleaseIndex::ComputeIndexTargets() const { /*}}}*/ bool debReleaseIndex::GetIndexes(pkgAcquire *Owner, bool const &GetAll) const { + bool const tryInRelease = _config->FindB("Acquire::TryInRelease", true); + // special case for --print-uris if (GetAll) { vector *targets = ComputeIndexTargets(); @@ -239,18 +241,27 @@ bool debReleaseIndex::GetIndexes(pkgAcquire *Owner, bool const &GetAll) const // this is normally created in pkgAcqMetaSig, but if we run // in --print-uris mode, we add it here - new pkgAcqMetaIndex(Owner, MetaIndexURI("Release"), - MetaIndexInfo("Release"), "Release", - MetaIndexURI("Release.gpg"), - ComputeIndexTargets(), - new indexRecords (Dist)); + if (tryInRelease == false) + new pkgAcqMetaIndex(Owner, MetaIndexURI("Release"), + MetaIndexInfo("Release"), "Release", + MetaIndexURI("Release.gpg"), + ComputeIndexTargets(), + new indexRecords (Dist)); } - new pkgAcqMetaSig(Owner, MetaIndexURI("Release.gpg"), - MetaIndexInfo("Release.gpg"), "Release.gpg", - MetaIndexURI("Release"), MetaIndexInfo("Release"), "Release", - ComputeIndexTargets(), - new indexRecords (Dist)); + if (tryInRelease == true) + new pkgAcqMetaClearSig(Owner, MetaIndexURI("InRelease"), + MetaIndexInfo("InRelease"), "InRelease", + MetaIndexURI("Release"), MetaIndexInfo("Release"), "Release", + MetaIndexURI("Release.gpg"), MetaIndexInfo("Release.gpg"), "Release.gpg", + ComputeIndexTargets(), + new indexRecords (Dist)); + else + new pkgAcqMetaSig(Owner, MetaIndexURI("Release.gpg"), + MetaIndexInfo("Release.gpg"), "Release.gpg", + MetaIndexURI("Release"), MetaIndexInfo("Release"), "Release", + ComputeIndexTargets(), + new indexRecords (Dist)); return true; } diff --git a/debian/changelog b/debian/changelog index 77e8674a0..7ebbb1cb4 100644 --- a/debian/changelog +++ b/debian/changelog @@ -7,9 +7,16 @@ apt (0.9.7.9) UNRELEASED; urgency=low - ExecGPGV is a method which should never return, so mark it as such and fix the inconsistency of returning in error cases - don't close stdout/stderr if it is also the statusfd + - if ExecGPGV deals with a clear-signed file it will split this file + into data and signatures, pass it to gpgv for verification and + recombines it after that in a known-good way without unsigned blocks + and whitespaces resulting usually in more or less the same file as + before, but later code can be sure about the format * apt-pkg/acquire-item.cc: - keep the last good InRelease file around just as we do it with Release.gpg in case the new one we download isn't good for us + * apt-pkg/deb/debmetaindex.cc: + - reenable InRelease by default -- David Kalnischkies Fri, 15 Mar 2013 14:15:43 +0100 diff --git a/test/integration/test-ubuntu-bug-784473-InRelease-one-message-only b/test/integration/test-ubuntu-bug-784473-InRelease-one-message-only index d97011914..fad5488fb 100755 --- a/test/integration/test-ubuntu-bug-784473-InRelease-one-message-only +++ b/test/integration/test-ubuntu-bug-784473-InRelease-one-message-only @@ -26,6 +26,14 @@ MD5Sum: 2182897e0a2a0c09e760beaae117a015 2023 Packages.diff/Index 1b895931853981ad8204d2439821b999 4144 Packages.gz'; echo; cat ${RELEASE}.old;) > ${RELEASE} done -aptget update -qq > /dev/null 2> starts-with-unsigned.msg -sed -i 's#File .*InRelease#File InRelease#' starts-with-unsigned.msg -testfileequal starts-with-unsigned.msg "W: GPG error: file: unstable InRelease: File InRelease doesn't start with a clearsigned message" + +msgtest 'The unsigned garbage before signed block is' 'ignored' +aptget update -qq > /dev/null 2>&1 && msgpass || msgfail + +ROOTDIR="$(readlink -f .)" +testequal "Package files: + 100 ${ROOTDIR}/rootdir/var/lib/dpkg/status + release a=now + 500 file:${ROOTDIR}/aptarchive/ unstable/main i386 Packages + release a=unstable,n=unstable,c=main +Pinned packages:" aptcache policy -- cgit v1.2.3-70-g09d2