// Include Files /*{{{*/
#include<config.h>
+#include <errno.h>
#include <stdio.h>
+#include <string.h>
#include <stdlib.h>
+#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
-#include <fcntl.h>
-
-#include <vector>
+#include <sys/wait.h>
-#include <apt-pkg/error.h>
-#include <apt-pkg/strutl.h>
-#include <apt-pkg/fileutl.h>
-#include <apt-pkg/configuration.h>
+#include<apt-pkg/configuration.h>
+#include<apt-pkg/error.h>
+#include<apt-pkg/strutl.h>
+#include<apt-pkg/fileutl.h>
+#include<apt-pkg/gpgv.h>
#include <apti18n.h>
/*}}}*/
+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);
std::clog << "Keyring path: " << trustedPath << std::endl;
}
- std::vector<string> keyrings;
+ std::vector<std::string> keyrings;
if (DirectoryExists(trustedPath))
keyrings = GetListOfFilesInDir(trustedPath, "gpg", false, true);
if (RealFileExists(trustedFile) == true)
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<string>::const_iterator K = keyrings.begin();
+ for (std::vector<std::string>::const_iterator K = keyrings.begin();
K != keyrings.end(); ++K)
{
Args.push_back("--keyring");
}
}
- Args.push_back(FileGPG.c_str());
+ int sigFd = -1;
+ int dataFd = -1;
+ std::vector<std::string> 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)
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<std::string> const &ContentHeader, int const SignatureFile)
+{
+ FILE *clean_file = fopen(OutFile.c_str(), "w");
+ fputs("-----BEGIN PGP SIGNED MESSAGE-----\n", clean_file);
+ for (std::vector<std::string>::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<std::string> * 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;
+}
projects / apt.git / blobdiff