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 +++++++++ apt-pkg/indexcopy.cc | 122 +----------------------------------------- apt-pkg/indexcopy.h | 15 +++--- apt-pkg/makefile | 14 +++-- 5 files changed, 179 insertions(+), 134 deletions(-) create mode 100644 apt-pkg/contrib/gpgv.cc create mode 100644 apt-pkg/contrib/gpgv.h (limited to 'apt-pkg') 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 diff --git a/apt-pkg/indexcopy.cc b/apt-pkg/indexcopy.cc index aa1f01a4a..f53989bdb 100644 --- a/apt-pkg/indexcopy.cc +++ b/apt-pkg/indexcopy.cc @@ -593,9 +593,9 @@ bool SigVerify::CopyAndVerify(string CDROM,string Name,vector &SigList, if(pid == 0) { if (useInRelease == true) - RunGPGV(inrelease, inrelease); + ExecGPGV(inrelease, inrelease); else - RunGPGV(release, releasegpg); + ExecGPGV(release, releasegpg); } if(!ExecWait(pid, "gpgv")) { @@ -639,124 +639,6 @@ bool SigVerify::CopyAndVerify(string CDROM,string Name,vector &SigList, } } - return true; -} - /*}}}*/ -// SigVerify::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. Also, as - the cdrom code currently can not use the gpgv method we have two places - these need to be done - so the place for this method is wrong but better - than code duplication… */ -bool SigVerify::RunGPGV(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/indexcopy.h b/apt-pkg/indexcopy.h index e3de1afd9..49e724f2f 100644 --- a/apt-pkg/indexcopy.h +++ b/apt-pkg/indexcopy.h @@ -14,6 +14,9 @@ #include #include +#include +#include + #ifndef APT_8_CLEANER_HEADERS using std::string; using std::vector; @@ -96,13 +99,13 @@ class SigVerify /*{{{*/ bool CopyAndVerify(std::string CDROM,std::string Name,std::vector &SigList, std::vector PkgList,std::vector SrcList); - /** \brief generates and run the command to verify a file with gpgv */ - static bool RunGPGV(std::string const &File, std::string const &FileOut, - int const &statusfd, int fd[2]); - inline static bool RunGPGV(std::string const &File, std::string const &FileOut, + __deprecated static bool RunGPGV(std::string const &File, std::string const &FileOut, + int const &statusfd, int fd[2]) { + return ExecGPGV(File, FileOut, statusfd, fd); + }; + __deprecated static bool RunGPGV(std::string const &File, std::string const &FileOut, int const &statusfd = -1) { - int fd[2]; - return RunGPGV(File, FileOut, statusfd, fd); + return ExecGPGV(File, FileOut, statusfd); }; }; /*}}}*/ diff --git a/apt-pkg/makefile b/apt-pkg/makefile index 27d7ead24..59729faf5 100644 --- a/apt-pkg/makefile +++ b/apt-pkg/makefile @@ -27,15 +27,13 @@ APT_DOMAIN:=libapt-pkg$(LIBAPTPKG_MAJOR) SOURCE = contrib/mmap.cc contrib/error.cc contrib/strutl.cc \ contrib/configuration.cc contrib/progress.cc contrib/cmndline.cc \ contrib/hashsum.cc contrib/md5.cc contrib/sha1.cc \ - contrib/sha2_internal.cc\ - contrib/hashes.cc \ + contrib/sha2_internal.cc contrib/hashes.cc \ contrib/cdromutl.cc contrib/crc-16.cc contrib/netrc.cc \ - contrib/fileutl.cc -HEADERS = mmap.h error.h configuration.h fileutl.h cmndline.h netrc.h\ - md5.h crc-16.h cdromutl.h strutl.h sptr.h sha1.h sha2.h sha256.h\ - sha2_internal.h \ - hashes.h hashsum_template.h\ - macros.h weakptr.h + contrib/fileutl.cc contrib/gpgv.cc +HEADERS = mmap.h error.h configuration.h fileutl.h cmndline.h netrc.h \ + md5.h crc-16.h cdromutl.h strutl.h sptr.h sha1.h sha2.h sha256.h \ + sha2_internal.h hashes.h hashsum_template.h \ + macros.h weakptr.h gpgv.h # Source code for the core main library SOURCE+= pkgcache.cc version.cc depcache.cc \ -- cgit v1.2.3 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 ++++-- 3 files changed, 40 insertions(+), 14 deletions(-) (limited to 'apt-pkg') 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; }; }; /*}}}*/ -- cgit v1.2.3 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 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) (limited to 'apt-pkg') 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); -- cgit v1.2.3 From 39f38a81b85edf2e1bdc4e92267a63cc6c928734 Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Fri, 15 Mar 2013 14:55:43 +0100 Subject: * 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/acquire-item.cc | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) (limited to 'apt-pkg') diff --git a/apt-pkg/acquire-item.cc b/apt-pkg/acquire-item.cc index a30e98858..39b842dfb 100644 --- a/apt-pkg/acquire-item.cc +++ b/apt-pkg/acquire-item.cc @@ -1503,20 +1503,17 @@ void pkgAcqMetaIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf) if (AuthPass == true) { // gpgv method failed, if we have a good signature - string LastGoodSigFile = _config->FindDir("Dir::State::lists"); - if (DestFile == SigFile) - LastGoodSigFile.append(URItoFileName(RealURI)); - else - LastGoodSigFile.append("partial/").append(URItoFileName(RealURI)).append(".gpg.reverify"); + string LastGoodSigFile = _config->FindDir("Dir::State::lists").append("partial/").append(URItoFileName(RealURI)); + if (DestFile != SigFile) + LastGoodSigFile.append(".gpg"); + LastGoodSigFile.append(".reverify"); if(FileExists(LastGoodSigFile)) { + string VerifiedSigFile = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI); if (DestFile != SigFile) - { - string VerifiedSigFile = _config->FindDir("Dir::State::lists") + - URItoFileName(RealURI) + ".gpg"; - Rename(LastGoodSigFile,VerifiedSigFile); - } + VerifiedSigFile.append(".gpg"); + Rename(LastGoodSigFile, VerifiedSigFile); Status = StatTransientNetworkError; _error->Warning(_("A error occurred during the signature " "verification. The repository is not updated " @@ -1577,6 +1574,15 @@ pkgAcqMetaClearSig::pkgAcqMetaClearSig(pkgAcquire *Owner, /*{{{*/ MetaSigURI(MetaSigURI), MetaSigURIDesc(MetaSigURIDesc), MetaSigShortDesc(MetaSigShortDesc) { SigFile = DestFile; + + // keep the old InRelease around in case of transistent network errors + string const Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI); + struct stat Buf; + if (stat(Final.c_str(),&Buf) == 0) + { + string const LastGoodSig = DestFile + ".reverify"; + Rename(Final,LastGoodSig); + } } /*}}}*/ // pkgAcqMetaClearSig::Custom600Headers - Insert custom request headers /*{{{*/ -- cgit v1.2.3 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') 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 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 +++-- 3 files changed, 319 insertions(+), 55 deletions(-) (limited to 'apt-pkg') 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; } -- cgit v1.2.3 From bea263c2c0ecd6715ce996fd9b54599ac2cfa7c2 Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Sat, 16 Mar 2013 12:40:43 +0100 Subject: ensure that we fclose/unlink/free in the new gpg-code as soon as possible --- apt-pkg/contrib/gpgv.cc | 27 ++++++++++++++++++++++----- 1 file changed, 22 insertions(+), 5 deletions(-) (limited to 'apt-pkg') diff --git a/apt-pkg/contrib/gpgv.cc b/apt-pkg/contrib/gpgv.cc index c236a7289..5921d7c67 100644 --- a/apt-pkg/contrib/gpgv.cc +++ b/apt-pkg/contrib/gpgv.cc @@ -214,19 +214,25 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, ioprintf(std::cerr, _("Waited for %s but it wasn't there"), "gpgv"); UNLINK_EXIT(EINTERNAL); } +#undef UNLINK_EXIT + // we don't need the files any longer as we have the filedescriptors still open + unlink(sig); + unlink(data); + free(sig); + free(data); // check if it exit'ed normally … if (WIFEXITED(Status) == false) { ioprintf(std::cerr, _("Sub-process %s exited unexpectedly"), "gpgv"); - UNLINK_EXIT(EINTERNAL); + 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)); + exit(WEXITSTATUS(Status)); } /* looks like its fine. Our caller will check the status fd, @@ -236,12 +242,11 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, if (RecombineToClearSignedFile(File, dataFd, dataHeader, sigFd) == false) { _error->DumpErrors(std::cerr); - UNLINK_EXIT(EINTERNAL); + exit(EINTERNAL); } // everything fine, we have a clean file now! - UNLINK_EXIT(0); -#undef UNLINK_EXIT + exit(0); } exit(EINTERNAL); // unreachable safe-guard } @@ -259,7 +264,10 @@ bool RecombineToClearSignedFile(std::string const &OutFile, int const ContentFil FILE *data_file = fdopen(ContentFile, "r"); FILE *sig_file = fdopen(SignatureFile, "r"); if (data_file == NULL || sig_file == NULL) + { + fclose(clean_file); 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) @@ -287,13 +295,21 @@ bool SplitClearSignedFile(std::string const &InFile, int const ContentFile, { out_content = fdopen(ContentFile, "w"); if (out_content == NULL) + { + fclose(in); 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) + { + fclose(in); + if (out_content != NULL) + fclose(out_content); return _error->Errno("fdopen", "Failed to open file to write signature to from %s", InFile.c_str()); + } } bool found_message_start = false; @@ -358,6 +374,7 @@ bool SplitClearSignedFile(std::string const &InFile, int const ContentFile, fclose(out_content); if (out_signature != NULL) fclose(out_signature); + fclose(in); return true; } -- cgit v1.2.3 From f1828b6977972b4ef6da6401602b7938f6570c32 Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Mon, 18 Mar 2013 19:36:55 +0100 Subject: - add method to open (maybe) clearsigned files transparently * ftparchive/writer.cc: - use OpenMaybeClearSignedFile to be free from detecting and skipping clearsigning metadata in dsc files --- apt-pkg/contrib/gpgv.cc | 55 ++++++++++++++++++++++++++++++++++++++++++++++++- apt-pkg/contrib/gpgv.h | 22 ++++++++++++++++++++ 2 files changed, 76 insertions(+), 1 deletion(-) (limited to 'apt-pkg') diff --git a/apt-pkg/contrib/gpgv.cc b/apt-pkg/contrib/gpgv.cc index 5921d7c67..fc16dd32c 100644 --- a/apt-pkg/contrib/gpgv.cc +++ b/apt-pkg/contrib/gpgv.cc @@ -19,7 +19,7 @@ #include /*}}}*/ -char * GenerateTemporaryFileTemplate(const char *basename) /*{{{*/ +static char * GenerateTemporaryFileTemplate(const char *basename) /*{{{*/ { const char *tmpdir = getenv("TMPDIR"); #ifdef P_tmpdir @@ -376,5 +376,58 @@ bool SplitClearSignedFile(std::string const &InFile, int const ContentFile, fclose(out_signature); fclose(in); + if (found_signature == true) + return _error->Error("Signature in file %s wasn't closed", InFile.c_str()); + + // if we haven't found any of them, this an unsigned file, + // so don't generate an error, but splitting was unsuccessful none-the-less + if (found_message_start == false && found_message_end == false) + return false; + // otherwise one missing indicates a syntax error + else if (found_message_start == false || found_message_end == false) + return _error->Error("Splitting of file %s failed as it doesn't contain all expected parts", InFile.c_str()); + return true; } + /*}}}*/ +bool OpenMaybeClearSignedFile(std::string const &ClearSignedFileName, FileFd &MessageFile) /*{{{*/ +{ + char * const message = GenerateTemporaryFileTemplate("fileutl.message"); + int const messageFd = mkstemp(message); + if (messageFd == -1) + { + free(message); + return _error->Errno("mkstemp", "Couldn't create temporary file to work with %s", ClearSignedFileName.c_str()); + } + // we have the fd, thats enough for us + unlink(message); + free(message); + + int const duppedMsg = dup(messageFd); + if (duppedMsg == -1) + return _error->Errno("dup", "Couldn't duplicate FD to work with %s", ClearSignedFileName.c_str()); + + _error->PushToStack(); + bool const splitDone = SplitClearSignedFile(ClearSignedFileName.c_str(), messageFd, NULL, -1); + bool const errorDone = _error->PendingError(); + _error->MergeWithStack(); + if (splitDone == false) + { + close(duppedMsg); + + if (errorDone == true) + return false; + + // we deal with an unsigned file + MessageFile.Open(ClearSignedFileName, FileFd::ReadOnly); + } + else // clear-signed + { + if (lseek(duppedMsg, 0, SEEK_SET) < 0) + return _error->Errno("lseek", "Unable to seek back in message fd for file %s", ClearSignedFileName.c_str()); + MessageFile.OpenDescriptor(duppedMsg, FileFd::ReadOnly, true); + } + + return MessageFile.Failed() == false; +} + /*}}}*/ diff --git a/apt-pkg/contrib/gpgv.h b/apt-pkg/contrib/gpgv.h index 8e04855e4..ab7d35ab1 100644 --- a/apt-pkg/contrib/gpgv.h +++ b/apt-pkg/contrib/gpgv.h @@ -12,6 +12,8 @@ #include #include +#include + #if __GNUC__ >= 4 #define APT_noreturn __attribute__ ((noreturn)) #else @@ -52,10 +54,17 @@ inline void ExecGPGV(std::string const &File, std::string const &FileSig, * The code doesn't support dash-encoded lines as these are not * expected to be present in files we have to deal with. * + * The content of the split files is undefined if the splitting was + * unsuccessful. + * + * Note that trying to split an unsigned file will fail, but + * not generate an error message. + * * @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 + * @return true if the splitting was successful, false otherwise */ bool SplitClearSignedFile(std::string const &InFile, int const ContentFile, std::vector * const ContentHeader, int const SignatureFile); @@ -74,4 +83,17 @@ bool SplitClearSignedFile(std::string const &InFile, int const ContentFile, bool RecombineToClearSignedFile(std::string const &OutFile, int const ContentFile, std::vector const &ContentHeader, int const SignatureFile); +/** \brief open a file which might be clear-signed + * + * This method tries to extract the (signed) message of a file. + * If the file isn't signed it will just open the given filename. + * Otherwise the message is extracted to a temporary file which + * will be opened instead. + * + * @param ClearSignedFileName is the name of the file to open + * @param[out] MessageFile is the FileFd in which the file will be opened + * @return true if opening was successful, otherwise false + */ +bool OpenMaybeClearSignedFile(std::string const &ClearSignedFileName, FileFd &MessageFile); + #endif -- cgit v1.2.3 From 233b78083f6f79730fcb5a6faeb74e2a78b6038a Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Mon, 18 Mar 2013 22:57:08 +0100 Subject: * apt-pkg/deb/debindexfile.cc, apt-pkg/deb/deblistparser.cc: - use OpenMaybeClearSignedFile to be free from detecting and skipping clearsigning metadata in dsc and Release files We can't write a "clean" file to disk as not all acquire methods copy Release files before checking them (e.g. cdrom), so this reverts recombining, but uses the method we use for dsc files also in the two places we deal with Release files --- apt-pkg/contrib/gpgv.cc | 44 ++------------------------------------------ apt-pkg/contrib/gpgv.h | 14 -------------- apt-pkg/deb/debindexfile.cc | 8 +++++++- apt-pkg/deb/deblistparser.cc | 12 +----------- apt-pkg/indexrecords.cc | 6 +++++- 5 files changed, 15 insertions(+), 69 deletions(-) (limited to 'apt-pkg') diff --git a/apt-pkg/contrib/gpgv.cc b/apt-pkg/contrib/gpgv.cc index fc16dd32c..7e244c623 100644 --- a/apt-pkg/contrib/gpgv.cc +++ b/apt-pkg/contrib/gpgv.cc @@ -215,7 +215,7 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, UNLINK_EXIT(EINTERNAL); } #undef UNLINK_EXIT - // we don't need the files any longer as we have the filedescriptors still open + // we don't need the files any longer unlink(sig); unlink(data); free(sig); @@ -235,52 +235,12 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, 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); - exit(EINTERNAL); - } - - // everything fine, we have a clean file now! + // everything fine exit(0); } 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) - { - fclose(clean_file); - 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) diff --git a/apt-pkg/contrib/gpgv.h b/apt-pkg/contrib/gpgv.h index ab7d35ab1..8cbe553bc 100644 --- a/apt-pkg/contrib/gpgv.h +++ b/apt-pkg/contrib/gpgv.h @@ -69,20 +69,6 @@ inline void ExecGPGV(std::string const &File, std::string const &FileSig, 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); - /** \brief open a file which might be clear-signed * * This method tries to extract the (signed) message of a file. diff --git a/apt-pkg/deb/debindexfile.cc b/apt-pkg/deb/debindexfile.cc index de645bb6e..909dfcf47 100644 --- a/apt-pkg/deb/debindexfile.cc +++ b/apt-pkg/deb/debindexfile.cc @@ -22,6 +22,7 @@ #include #include #include +#include #include /*}}}*/ @@ -337,7 +338,12 @@ bool debPackagesIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const if (releaseExists == true || FileExists(ReleaseFile) == true) { - FileFd Rel(ReleaseFile,FileFd::ReadOnly); + FileFd Rel; + // Beware: The 'Release' file might be clearsigned in case the + // signature for an 'InRelease' file couldn't be checked + if (OpenMaybeClearSignedFile(ReleaseFile, Rel) == false) + return false; + if (_error->PendingError() == true) return false; Parser.LoadReleaseInfo(File,Rel,Section); diff --git a/apt-pkg/deb/deblistparser.cc b/apt-pkg/deb/deblistparser.cc index b84bd6fdd..2c014a734 100644 --- a/apt-pkg/deb/deblistparser.cc +++ b/apt-pkg/deb/deblistparser.cc @@ -800,13 +800,12 @@ bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator &FileI, map_ptrloc const storage = WriteUniqString(component); FileI->Component = storage; - // FIXME: Code depends on the fact that Release files aren't compressed + // FIXME: should use FileFd and TagSection FILE* release = fdopen(dup(File.Fd()), "r"); if (release == NULL) return false; char buffer[101]; - bool gpgClose = false; while (fgets(buffer, sizeof(buffer), release) != NULL) { size_t len = 0; @@ -818,15 +817,6 @@ bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator &FileI, if (buffer[len] == '\0') continue; - // only evalute the first GPG section - if (strncmp("-----", buffer, 5) == 0) - { - if (gpgClose == true) - break; - gpgClose = true; - continue; - } - // seperate the tag from the data const char* dataStart = strchr(buffer + len, ':'); if (dataStart == NULL) diff --git a/apt-pkg/indexrecords.cc b/apt-pkg/indexrecords.cc index af2639beb..1461a24bb 100644 --- a/apt-pkg/indexrecords.cc +++ b/apt-pkg/indexrecords.cc @@ -12,6 +12,7 @@ #include #include #include +#include #include #include @@ -57,7 +58,10 @@ bool indexRecords::Exists(string const &MetaKey) const bool indexRecords::Load(const string Filename) /*{{{*/ { - FileFd Fd(Filename, FileFd::ReadOnly); + FileFd Fd; + if (OpenMaybeClearSignedFile(Filename, Fd) == false) + return false; + pkgTagFile TagFile(&Fd, Fd.Size() + 256); // XXX if (_error->PendingError() == true) { -- cgit v1.2.3 From b408e4ad0010b273dac0af7dc87ab61062d89e49 Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Tue, 19 Mar 2013 10:49:57 +0100 Subject: use FileFd instead of int fds to tidy up the interface a bit --- apt-pkg/contrib/gpgv.cc | 103 ++++++++++++++++++++++-------------------------- apt-pkg/contrib/gpgv.h | 12 +++--- 2 files changed, 53 insertions(+), 62 deletions(-) (limited to 'apt-pkg') diff --git a/apt-pkg/contrib/gpgv.cc b/apt-pkg/contrib/gpgv.cc index 7e244c623..54cc4c6d0 100644 --- a/apt-pkg/contrib/gpgv.cc +++ b/apt-pkg/contrib/gpgv.cc @@ -41,6 +41,7 @@ static char * GenerateTemporaryFileTemplate(const char *basename) /*{{{*/ 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 + and split up the clear-signed file in message and signature for gpgv */ void ExecGPGV(std::string const &File, std::string const &FileGPG, int const &statusfd, int fd[2]) @@ -108,8 +109,6 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, } } - int sigFd = -1; - int dataFd = -1; std::vector dataHeader; char * sig = NULL; char * data = NULL; @@ -126,17 +125,29 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, data = GenerateTemporaryFileTemplate("apt.data"); if (sig == NULL || data == NULL) { + ioprintf(std::cerr, "Couldn't create tempfile names for splitting up %s", File.c_str()); + exit(EINTERNAL); + } + + int const sigFd = mkstemp(sig); + int const dataFd = mkstemp(data); + if (sigFd == -1 || dataFd == -1) + { + if (dataFd != -1) + unlink(sig); + if (sigFd != -1) + unlink(data); 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); + FileFd signature; + signature.OpenDescriptor(sigFd, FileFd::WriteOnly, true); + FileFd message; + message.OpenDescriptor(dataFd, FileFd::WriteOnly, true); - if (dataFd == -1 || sigFd == -1 || duppedDataFd == -1 || duppedSigFd == -1 || - SplitClearSignedFile(File, duppedDataFd, &dataHeader, duppedSigFd) == false) + if (signature.Failed() == true || message.Failed() == true || + SplitClearSignedFile(File, &message, &dataHeader, &signature) == false) { if (dataFd != -1) unlink(sig); @@ -145,8 +156,6 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, 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); } @@ -242,36 +251,13 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG, } /*}}}*/ // SplitClearSignedFile - split message into data/signature /*{{{*/ -bool SplitClearSignedFile(std::string const &InFile, int const ContentFile, - std::vector * const ContentHeader, int const SignatureFile) +bool SplitClearSignedFile(std::string const &InFile, FileFd * const ContentFile, + std::vector * const ContentHeader, FileFd * 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) - { - fclose(in); - 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) - { - fclose(in); - if (out_content != NULL) - fclose(out_content); - 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; @@ -280,7 +266,8 @@ bool SplitClearSignedFile(std::string const &InFile, int const ContentFile, char *buf = NULL; size_t buf_size = 0; - while (getline(&buf, &buf_size, in) != -1) + ssize_t line_len = 0; + while ((line_len = getline(&buf, &buf_size, in)) != -1) { _strrstrip(buf); if (found_message_start == false) @@ -305,35 +292,40 @@ bool SplitClearSignedFile(std::string const &InFile, int const ContentFile, { found_signature = true; found_message_end = true; - if (out_signature != NULL) - fprintf(out_signature, "%s\n", buf); + if (SignatureFile != NULL) + { + SignatureFile->Write(buf, strlen(buf)); + SignatureFile->Write("\n", 1); + } } 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); + if (ContentFile != NULL) + ContentFile->Write(buf, strlen(buf)); first_line = false; } - else if (out_content != NULL) - fprintf(out_content, "\n%s", buf); + else if (ContentFile != NULL) + { + ContentFile->Write("\n", 1); + ContentFile->Write(buf, strlen(buf)); + } } } else if (found_signature == true) { - if (out_signature != NULL) - fprintf(out_signature, "%s\n", buf); + if (SignatureFile != NULL) + { + SignatureFile->Write(buf, strlen(buf)); + SignatureFile->Write("\n", 1); + } 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); fclose(in); if (found_signature == true) @@ -363,17 +355,17 @@ bool OpenMaybeClearSignedFile(std::string const &ClearSignedFileName, FileFd &Me unlink(message); free(message); - int const duppedMsg = dup(messageFd); - if (duppedMsg == -1) - return _error->Errno("dup", "Couldn't duplicate FD to work with %s", ClearSignedFileName.c_str()); + MessageFile.OpenDescriptor(messageFd, FileFd::ReadWrite, true); + if (MessageFile.Failed() == true) + return _error->Error("Couldn't open temporary file to work with %s", ClearSignedFileName.c_str()); _error->PushToStack(); - bool const splitDone = SplitClearSignedFile(ClearSignedFileName.c_str(), messageFd, NULL, -1); + bool const splitDone = SplitClearSignedFile(ClearSignedFileName.c_str(), &MessageFile, NULL, NULL); bool const errorDone = _error->PendingError(); _error->MergeWithStack(); if (splitDone == false) { - close(duppedMsg); + MessageFile.Close(); if (errorDone == true) return false; @@ -383,9 +375,8 @@ bool OpenMaybeClearSignedFile(std::string const &ClearSignedFileName, FileFd &Me } else // clear-signed { - if (lseek(duppedMsg, 0, SEEK_SET) < 0) - return _error->Errno("lseek", "Unable to seek back in message fd for file %s", ClearSignedFileName.c_str()); - MessageFile.OpenDescriptor(duppedMsg, FileFd::ReadOnly, true); + if (MessageFile.Seek(0) == false) + return _error->Errno("lseek", "Unable to seek back in message for file %s", ClearSignedFileName.c_str()); } return MessageFile.Failed() == false; diff --git a/apt-pkg/contrib/gpgv.h b/apt-pkg/contrib/gpgv.h index 8cbe553bc..1f877fc2d 100644 --- a/apt-pkg/contrib/gpgv.h +++ b/apt-pkg/contrib/gpgv.h @@ -48,8 +48,8 @@ inline void ExecGPGV(std::string const &File, std::string const &FileSig, * 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. + * If a FileFd pointers is NULL it will not be used and the content + * which would have been written to it is silently discarded. * * The code doesn't support dash-encoded lines as these are not * expected to be present in files we have to deal with. @@ -61,13 +61,13 @@ inline void ExecGPGV(std::string const &File, std::string const &FileSig, * not generate an error message. * * @param InFile is the clear-signed file - * @param ContentFile is the Fd the message will be written to + * @param ContentFile is the FileFd 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 + * @param SignatureFile is the FileFd all signatures will be written to * @return true if the splitting was successful, false otherwise */ -bool SplitClearSignedFile(std::string const &InFile, int const ContentFile, - std::vector * const ContentHeader, int const SignatureFile); +bool SplitClearSignedFile(std::string const &InFile, FileFd * const ContentFile, + std::vector * const ContentHeader, FileFd * const SignatureFile); /** \brief open a file which might be clear-signed * -- cgit v1.2.3 From cb32348956441e33733e6bd8c2c572f19600dc25 Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Tue, 19 Mar 2013 12:37:50 +0100 Subject: support dash-escaped text in clearsigned files as implementations are free to escape all lines (we have no lines in our files which need to be escaped as these would be invalid fieldnames) and while ExecGPGV would detect dash-escaped text as invalid (as its not expected in messages with detached signatures) it would be possible to "comment" lines in (signed) dsc files which are only parsed but not verified --- apt-pkg/contrib/gpgv.cc | 23 ++++++++++++----------- apt-pkg/contrib/gpgv.h | 3 --- 2 files changed, 12 insertions(+), 14 deletions(-) (limited to 'apt-pkg') diff --git a/apt-pkg/contrib/gpgv.cc b/apt-pkg/contrib/gpgv.cc index 54cc4c6d0..ba059dd87 100644 --- a/apt-pkg/contrib/gpgv.cc +++ b/apt-pkg/contrib/gpgv.cc @@ -298,20 +298,21 @@ bool SplitClearSignedFile(std::string const &InFile, FileFd * const ContentFile, SignatureFile->Write("\n", 1); } } - else if (found_message_end == false) + else if (found_message_end == false) // we are in the message block { - // we are in the message block + // we don't have any fields which need dash-escaped, + // but implementations are free to encode all lines … + char const * dashfree = buf; + if (strncmp(dashfree, "- ", 2) == 0) + dashfree += 2; if(first_line == true) // first line does not need a newline - { - if (ContentFile != NULL) - ContentFile->Write(buf, strlen(buf)); first_line = false; - } else if (ContentFile != NULL) - { ContentFile->Write("\n", 1); - ContentFile->Write(buf, strlen(buf)); - } + else + continue; + if (ContentFile != NULL) + ContentFile->Write(dashfree, strlen(dashfree)); } } else if (found_signature == true) @@ -333,10 +334,10 @@ bool SplitClearSignedFile(std::string const &InFile, FileFd * const ContentFile, // if we haven't found any of them, this an unsigned file, // so don't generate an error, but splitting was unsuccessful none-the-less - if (found_message_start == false && found_message_end == false) + if (first_line == true && found_message_start == false && found_message_end == false) return false; // otherwise one missing indicates a syntax error - else if (found_message_start == false || found_message_end == false) + else if (first_line == false || found_message_start == false || found_message_end == false) return _error->Error("Splitting of file %s failed as it doesn't contain all expected parts", InFile.c_str()); return true; diff --git a/apt-pkg/contrib/gpgv.h b/apt-pkg/contrib/gpgv.h index 1f877fc2d..08b10a97a 100644 --- a/apt-pkg/contrib/gpgv.h +++ b/apt-pkg/contrib/gpgv.h @@ -51,9 +51,6 @@ inline void ExecGPGV(std::string const &File, std::string const &FileSig, * If a FileFd pointers is NULL it will not be used and the content * which would have been written to it is silently discarded. * - * The code doesn't support dash-encoded lines as these are not - * expected to be present in files we have to deal with. - * * The content of the split files is undefined if the splitting was * unsuccessful. * -- cgit v1.2.3