tests/zypp/KeyRing_test.cc

   1
   2 #include <iostream>
   3 #include <fstream>
   4 #include <list>
   5 #include <string>
   6
   7 #include "zypp/base/Logger.h"
   8 #include "zypp/base/Exception.h"
   9 #include "zypp/KeyRing.h"
  10 #include "zypp/PublicKey.h"
  11 #include "zypp/TmpPath.h"
  12
  13 #include <boost/test/auto_unit_test.hpp>
  14
  15 #include "KeyRingTestReceiver.h"
  16
  17 using boost::unit_test::test_suite;
  18 using boost::unit_test::test_case;
  19
  20 using namespace std;
  21 using namespace zypp;
  22 using namespace zypp::filesystem;
  23
  24 #define DATADIR (Pathname(TESTS_SRC_DIR) +  "/zypp/data/KeyRing")
  25
  26 BOOST_AUTO_TEST_CASE(keyring_test)
  27 {
  28   PublicKey key( Pathname(DATADIR) + "public.asc" );
  29
  30  /**
  31   * scenario #1
  32   * import a not trusted key
  33   * ask for trust, answer yes
  34   * ask for import, answer no
  35   */
  36   {
  37     KeyRingTestReceiver keyring_callbacks;
  38     KeyRingTestSignalReceiver receiver;
  39     // base sandbox for playing
  40     TmpDir tmp_dir;
  41     KeyRing keyring( tmp_dir.path() );
  42
  43     BOOST_CHECK_EQUAL( keyring.publicKeys().size(), (unsigned) 0 );
  44     BOOST_CHECK_EQUAL( keyring.trustedPublicKeys().size(), (unsigned) 0 );
  45
  46     keyring.importKey( key, false );
  47
  48     BOOST_CHECK_EQUAL( keyring.publicKeys().size(), (unsigned) 1 );
  49     BOOST_CHECK_EQUAL( keyring.trustedPublicKeys().size(), (unsigned) 0 );
  50
  51     BOOST_CHECK_MESSAGE( keyring.isKeyKnown( key.id() ), "Imported untrusted key should be known");
  52     BOOST_CHECK_MESSAGE( ! keyring.isKeyTrusted( key.id() ), "Imported untrusted key should be untrusted");
  53
  54     keyring_callbacks.answerTrustKey(true);
  55     bool to_continue = keyring.verifyFileSignatureWorkflow( DATADIR + "repomd.xml", "Blah Blah", DATADIR + "repomd.xml.asc");
  56
  57     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedAcceptUnknownKey(), "Should not ask for unknown key, it was known");
  58     BOOST_CHECK_MESSAGE( keyring_callbacks.askedTrustKey(), "Verify Signature Workflow with only 1 untrusted key should ask user wether to trust");
  59     BOOST_CHECK_MESSAGE( keyring_callbacks.askedImportKey(), "Trusting a key should ask for import");
  60     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedAcceptVerFailed(), "The signature validates");
  61     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedAcceptUnsignedFile(), "It is a signed file, so dont ask the opposite");
  62
  63     BOOST_CHECK_MESSAGE( to_continue, "We did not import, but we trusted and signature validates.");
  64   }
  65
  66   /**
  67   * scenario #1.1
  68   * import a not trusted key
  69   * ask for trust, answer yes
  70   * ask for import, answer no
  71   * vorrupt the file and check
  72   */
  73   {
  74     KeyRingTestReceiver keyring_callbacks;
  75     KeyRingTestSignalReceiver receiver;
  76     // base sandbox for playing
  77     TmpDir tmp_dir;
  78     KeyRing keyring( tmp_dir.path() );
  79
  80     BOOST_CHECK_EQUAL( keyring.publicKeys().size(), (unsigned) 0 );
  81     BOOST_CHECK_EQUAL( keyring.trustedPublicKeys().size(), (unsigned) 0 );
  82
  83     keyring.importKey( key, false );
  84
  85     keyring_callbacks.answerTrustKey(true);
  86
  87     // now we will recheck with a corrupted file
  88     bool to_continue = keyring.verifyFileSignatureWorkflow( DATADIR + "repomd.xml.corrupted", "Blah Blah", DATADIR + "repomd.xml.asc");
  89
  90     // check wether the user got the right questions
  91     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedAcceptUnknownKey(), "Should not ask for unknown key, it was known");
  92     BOOST_CHECK_MESSAGE( keyring_callbacks.askedTrustKey(), "Verify Signature Workflow with only 1 untrusted key should ask user wether to trust");
  93     BOOST_CHECK_MESSAGE( keyring_callbacks.askedImportKey(), "Trusting a key should ask for import");
  94     BOOST_CHECK_MESSAGE( keyring_callbacks.askedAcceptVerFailed(), "The signature does not validates");
  95     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedAcceptUnsignedFile(), "It is a signed file, so dont ask the opposite");
  96
  97     BOOST_CHECK_MESSAGE( ! to_continue, "We did not continue with a corrupted file");
  98   }
  99
 100    /**
 101   * scenario #1.2
 102   * import a not trusted key
 103   * ask for trust, answer yes
 104   * ask for import, answer no
 105   * check without signature
 106   */
 107   {
 108     KeyRingTestReceiver keyring_callbacks;
 109     KeyRingTestSignalReceiver receiver;
 110     // base sandbox for playing
 111     TmpDir tmp_dir;
 112     KeyRing keyring( tmp_dir.path() );
 113
 114     keyring.importKey( key, false );
 115
 116     keyring_callbacks.answerTrustKey(true);
 117     // now we will recheck with a unsigned file
 118     bool to_continue = keyring.verifyFileSignatureWorkflow( DATADIR + "repomd.xml", "Blah Blah", Pathname() );
 119
 120     // check wether the user got the right questions
 121     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedAcceptUnknownKey(), "Should not ask for unknown key, it was known");
 122     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedTrustKey(), "No signature, no key to trust");
 123     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedImportKey(), "No signature, no key to import");
 124     BOOST_CHECK_MESSAGE( keyring_callbacks.askedAcceptUnsignedFile(), "Ask the user wether to accept an unsigned file");
 125     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedAcceptVerFailed(), "There is no signature to verify");
 126
 127     BOOST_CHECK_MESSAGE( ! to_continue, "We did not continue with a unsigned file");
 128   }
 129
 130  /** scenario #2
 131   * empty keyring
 132   * should ask for unknown key
 133   * answer no
 134   */
 135   {
 136     KeyRingTestReceiver keyring_callbacks;
 137     KeyRingTestSignalReceiver receiver;
 138     // base sandbox for playing
 139     TmpDir tmp_dir;
 140     KeyRing keyring( tmp_dir.path() );
 141
 142     BOOST_CHECK_MESSAGE( ! keyring.isKeyKnown( key.id() ), "empty keyring has not known keys");
 143
 144     //keyring_callbacks.answerAcceptUnknownKey(true);
 145     bool to_continue = keyring.verifyFileSignatureWorkflow( DATADIR + "repomd.xml", "Blah Blah", DATADIR + "repomd.xml.asc");
 146     BOOST_CHECK_MESSAGE(keyring_callbacks.askedAcceptUnknownKey(), "Should ask to accept unknown key, empty keyring");
 147     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedTrustKey(), "Unknown key cant be trusted");
 148     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedImportKey(), "Unknown key cant be imported");
 149
 150     BOOST_CHECK_MESSAGE( ! to_continue, "We answered no to accept unknown key");
 151   }
 152
 153   /** scenario #3
 154   * import trusted key
 155   * should ask nothing
 156   * should emit signal
 157   */
 158   {
 159     KeyRingTestReceiver keyring_callbacks;
 160     KeyRingTestSignalReceiver receiver;
 161     // base sandbox for playing
 162     TmpDir tmp_dir;
 163     KeyRing keyring( tmp_dir.path() );
 164
 165     BOOST_CHECK_EQUAL( keyring.publicKeys().size(), (unsigned) 0 );
 166     BOOST_CHECK_EQUAL( keyring.trustedPublicKeys().size(), (unsigned) 0 );
 167
 168     keyring.importKey( key, true );
 169
 170     BOOST_CHECK_EQUAL( receiver._trusted_key_added_called, true );
 171
 172     BOOST_CHECK_EQUAL( keyring.publicKeys().size(), (unsigned) 0 );
 173     BOOST_CHECK_EQUAL( keyring.trustedPublicKeys().size(), (unsigned) 1 );
 174
 175     BOOST_CHECK_MESSAGE( keyring.isKeyKnown( key.id() ), "Imported trusted key should be known");
 176     BOOST_CHECK_MESSAGE( keyring.isKeyTrusted( key.id() ), "Imported trusted key should be trusted");
 177
 178     bool to_continue = keyring.verifyFileSignatureWorkflow( DATADIR + "repomd.xml", "Blah Blah", DATADIR + "repomd.xml.asc");
 179
 180     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedAcceptUnknownKey(), "Should not ask for unknown key, it was known");
 181     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedTrustKey(), "Verify Signature Workflow with only 1 untrusted key should ask user wether to trust");
 182     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedImportKey(), "Trusting a key should ask for import");
 183     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedAcceptVerFailed(), "The signature validates");
 184     BOOST_CHECK_MESSAGE( ! keyring_callbacks.askedAcceptUnsignedFile(), "It is a signed file, so dont ask the opposite");
 185
 186     BOOST_CHECK_MESSAGE( to_continue, "We did not import, but we trusted and signature validates.");
 187   }
 188   //keyring.importKey( key, true );
 189   //BOOST_CHECK_EQUAL( receiver._trusted_key_added_called, true );
 190   //BOOST_CHECK_EQUAL( keyring.trustedPublicKeys().size(), 1 );
 191
 192   /* check signature id can be extracted */
 193
 194 }
 195
 196 BOOST_AUTO_TEST_CASE(signature_test)
 197 {
 198   PublicKey key( DATADIR + "public.asc" );
 199
 200   {
 201     KeyRingTestReceiver keyring_callbacks;
 202     KeyRingTestSignalReceiver receiver;
 203     // base sandbox for playing
 204     TmpDir tmp_dir;
 205     KeyRing keyring( tmp_dir.path() );
 206
 207     BOOST_CHECK_EQUAL( keyring.readSignatureKeyId( DATADIR + "repomd.xml.asc" ), "BD61D89BD98821BE" );
 208     BOOST_CHECK_THROW( keyring.readSignatureKeyId(Pathname()), Exception );
 209     TmpFile tmp;
 210     BOOST_CHECK_EQUAL( keyring.readSignatureKeyId(tmp.path()), "" );
 211
 212     keyring.importKey(key);
 213
 214     BOOST_CHECK(keyring.verifyFileSignature( DATADIR + "repomd.xml", DATADIR + "repomd.xml.asc"));
 215     BOOST_CHECK( ! keyring.verifyFileSignature( DATADIR + "repomd.xml.corrupted", DATADIR + "repomd.xml.asc"));
 216   }
 217 }
 218
 219