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