diff --git a/lang/cpp/src/data.cpp b/lang/cpp/src/data.cpp
index 547ec76e..7a93cbc2 100644
--- a/lang/cpp/src/data.cpp
+++ b/lang/cpp/src/data.cpp
@@ -1,275 +1,277 @@
 /*
   data.cpp - wraps a gpgme data object
   Copyright (C) 2003 Klarälvdalens Datakonsult AB
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifdef HAVE_CONFIG_H
  #include "config.h"
 #endif
 
 #include "data_p.h"
 #include "context_p.h"
 #include <error.h>
 #include <interfaces/dataprovider.h>
 
 #include <gpgme.h>
 
 #ifndef NDEBUG
 #include <iostream>
 #endif
 
 GpgME::Data::Private::~Private()
 {
     if (data) {
         gpgme_data_release(data);
     }
 }
 
 const GpgME::Data::Null GpgME::Data::null;
 
 GpgME::Data::Data()
 {
     gpgme_data_t data;
     const gpgme_error_t e = gpgme_data_new(&data);
     d.reset(new Private(e ? nullptr : data));
 }
 
 GpgME::Data::Data(const Null &)
     : d(new Private(nullptr))
 {
 
 }
 
 GpgME::Data::Data(gpgme_data_t data)
     : d(new Private(data))
 {
 
 }
 
 GpgME::Data::Data(const char *buffer, size_t size, bool copy)
 {
     gpgme_data_t data;
     const gpgme_error_t e = gpgme_data_new_from_mem(&data, buffer, size, int(copy));
     std::string sizestr = std::to_string(size);
     // Ignore errors as this is optional
     gpgme_data_set_flag(data, "size-hint", sizestr.c_str());
     d.reset(new Private(e ? nullptr : data));
 }
 
 GpgME::Data::Data(const char *filename)
 {
     gpgme_data_t data;
     const gpgme_error_t e = gpgme_data_new(&data);
     d.reset(new Private(e ? nullptr : data));
     if (!e) {
         setFileName(filename);
     }
 }
 
 GpgME::Data::Data(const char *filename, off_t offset, size_t length)
 {
     gpgme_data_t data;
     const gpgme_error_t e = gpgme_data_new_from_filepart(&data, filename, nullptr, offset, length);
     d.reset(new Private(e ? nullptr : data));
 }
 
 GpgME::Data::Data(FILE *fp)
 {
     gpgme_data_t data;
     const gpgme_error_t e = gpgme_data_new_from_stream(&data, fp);
     d.reset(new Private(e ? nullptr : data));
 }
 
 GpgME::Data::Data(FILE *fp, off_t offset, size_t length)
 {
     gpgme_data_t data;
     const gpgme_error_t e = gpgme_data_new_from_filepart(&data, nullptr, fp, offset, length);
     d.reset(new Private(e ? nullptr : data));
 }
 
 GpgME::Data::Data(int fd)
 {
     gpgme_data_t data;
     const gpgme_error_t e = gpgme_data_new_from_fd(&data, fd);
     d.reset(new Private(e ? nullptr : data));
 }
 
 GpgME::Data::Data(DataProvider *dp)
 {
     d.reset(new Private);
     if (!dp) {
         return;
     }
     if (!dp->isSupported(DataProvider::Read)) {
         d->cbs.read = nullptr;
     }
     if (!dp->isSupported(DataProvider::Write)) {
         d->cbs.write = nullptr;
     }
     if (!dp->isSupported(DataProvider::Seek)) {
         d->cbs.seek = nullptr;
     }
     if (!dp->isSupported(DataProvider::Release)) {
         d->cbs.release = nullptr;
     }
     const gpgme_error_t e = gpgme_data_new_from_cbs(&d->data, &d->cbs, dp);
     if (e) {
         d->data = nullptr;
     }
     if (dp->isSupported(DataProvider::Seek)) {
         off_t size = seek(0, SEEK_END);
         seek(0, SEEK_SET);
         std::string sizestr = std::to_string(size);
         // Ignore errors as this is optional
         gpgme_data_set_flag(d->data, "size-hint", sizestr.c_str());
     }
 #ifndef NDEBUG
     //std::cerr << "GpgME::Data(): DataProvider supports: "
     //    << ( d->cbs.read ? "read" : "no read" ) << ", "
     //    << ( d->cbs.write ? "write" : "no write" ) << ", "
     //    << ( d->cbs.seek ? "seek" : "no seek" ) << ", "
     //    << ( d->cbs.release ? "release" : "no release" ) << std::endl;
 #endif
 }
 
 bool GpgME::Data::isNull() const
 {
     return !d || !d->data;
 }
 
 GpgME::Data::Encoding GpgME::Data::encoding() const
 {
     switch (gpgme_data_get_encoding(d->data)) {
     case GPGME_DATA_ENCODING_NONE:   return AutoEncoding;
     case GPGME_DATA_ENCODING_BINARY: return BinaryEncoding;
     case GPGME_DATA_ENCODING_BASE64: return Base64Encoding;
     case GPGME_DATA_ENCODING_ARMOR:  return ArmorEncoding;
     case GPGME_DATA_ENCODING_MIME:   return MimeEncoding;
     case GPGME_DATA_ENCODING_URL:    return UrlEncoding;
     case GPGME_DATA_ENCODING_URLESC: return UrlEscEncoding;
     case GPGME_DATA_ENCODING_URL0:   return Url0Encoding;
     }
     return AutoEncoding;
 }
 
 GpgME::Error GpgME::Data::setEncoding(Encoding enc)
 {
     gpgme_data_encoding_t ge = GPGME_DATA_ENCODING_NONE;
     switch (enc) {
     case AutoEncoding:   ge = GPGME_DATA_ENCODING_NONE;   break;
     case BinaryEncoding: ge = GPGME_DATA_ENCODING_BINARY; break;
     case Base64Encoding: ge = GPGME_DATA_ENCODING_BASE64; break;
     case ArmorEncoding:  ge = GPGME_DATA_ENCODING_ARMOR;  break;
     case MimeEncoding:   ge = GPGME_DATA_ENCODING_MIME;  break;
     case UrlEncoding:    ge = GPGME_DATA_ENCODING_URL; break;
     case UrlEscEncoding: ge = GPGME_DATA_ENCODING_URLESC; break;
     case Url0Encoding:   ge = GPGME_DATA_ENCODING_URL0; break;
     }
     return Error(gpgme_data_set_encoding(d->data, ge));
 }
 
 GpgME::Data::Type GpgME::Data::type() const
 {
     if (isNull()) {
         return Invalid;
     }
     switch (gpgme_data_identify(d->data, 0)) {
     case GPGME_DATA_TYPE_INVALID:       return Invalid;
     case GPGME_DATA_TYPE_UNKNOWN:       return Unknown;
     case GPGME_DATA_TYPE_PGP_SIGNED:    return PGPSigned;
     case GPGME_DATA_TYPE_PGP_OTHER:     return PGPOther;
     case GPGME_DATA_TYPE_PGP_KEY:       return PGPKey;
     case GPGME_DATA_TYPE_CMS_SIGNED:    return CMSSigned;
     case GPGME_DATA_TYPE_CMS_ENCRYPTED: return CMSEncrypted;
     case GPGME_DATA_TYPE_CMS_OTHER:     return CMSOther;
     case GPGME_DATA_TYPE_X509_CERT:     return X509Cert;
     case GPGME_DATA_TYPE_PKCS12:        return PKCS12;
     case GPGME_DATA_TYPE_PGP_ENCRYPTED: return PGPEncrypted;
     case GPGME_DATA_TYPE_PGP_SIGNATURE: return PGPSignature;
     }
     return Invalid;
 }
 
 char *GpgME::Data::fileName() const
 {
     return gpgme_data_get_file_name(d->data);
 }
 
 GpgME::Error GpgME::Data::setFileName(const char *name)
 {
     return Error(gpgme_data_set_file_name(d->data, name));
 }
 
 ssize_t GpgME::Data::read(void *buffer, size_t length)
 {
     return gpgme_data_read(d->data, buffer, length);
 }
 
 ssize_t GpgME::Data::write(const void *buffer, size_t length)
 {
     return gpgme_data_write(d->data, buffer, length);
 }
 
 off_t GpgME::Data::seek(off_t offset, int whence)
 {
     return gpgme_data_seek(d->data, offset, whence);
 }
 
 GpgME::Error GpgME::Data::rewind()
 {
     return Error(gpgme_data_rewind(d->data));
 }
 
 std::vector<GpgME::Key> GpgME::Data::toKeys(Protocol proto) const
 {
     std::vector<GpgME::Key> ret;
     if (isNull()) {
         return ret;
     }
     auto ctx = GpgME::Context::createForProtocol(proto);
     if (!ctx) {
         return ret;
     }
 
     if (gpgme_op_keylist_from_data_start (ctx->impl()->ctx, d->data, 0)) {
         return ret;
     }
 
     gpgme_key_t key;
     while (!gpgme_op_keylist_next (ctx->impl()->ctx, &key)) {
         ret.push_back(GpgME::Key(key, false));
     }
+    gpgme_data_seek (d->data, 0, SEEK_SET);
+
     delete ctx;
     return ret;
 }
 
 std::string GpgME::Data::toString()
 {
   std::string ret;
   char buf[4096];
   size_t nread;
   seek (0, SEEK_SET);
   while ((nread = read (buf, 4096)) > 0)
     {
       ret += std::string (buf, nread);
     }
   seek (0, SEEK_SET);
   return ret;
 }