LCOV - code coverage report
Current view: top level - pkcs11/secret-store - test-secret-collection.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 100.0 % 273 273
Test Date: 2024-05-07 18:02:03 Functions: 100.0 % 23 23

            Line data    Source code
       1              : /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
       2              : /* test-secret-test->collection.c: Test the test->collection keyring
       3              : 
       4              :    Copyright (C) 2009 Stefan Walter
       5              : 
       6              :    The Gnome Keyring Library is free software; you can redistribute it and/or
       7              :    modify it under the terms of the GNU Library General Public License as
       8              :    published by the Free Software Foundation; either version 2 of the
       9              :    License, or (at your option) any later version.
      10              : 
      11              :    The Gnome Keyring Library is distributed in the hope that it will be useful,
      12              :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      13              :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14              :    Library General Public License for more details.
      15              : 
      16              :    You should have received a copy of the GNU Library General Public
      17              :    License along with the Gnome Library; see the file COPYING.LIB.  If not,
      18              :    <http://www.gnu.org/licenses/>.
      19              : 
      20              :    Author: Stef Walter <stef@memberwebs.com>
      21              : */
      22              : 
      23              : #include "config.h"
      24              : 
      25              : #include "mock-secret-module.h"
      26              : 
      27              : #include "secret-store/gkm-secret-data.h"
      28              : #include "secret-store/gkm-secret-collection.h"
      29              : #include "secret-store/gkm-secret-item.h"
      30              : 
      31              : #include "gkm/gkm-credential.h"
      32              : #include "gkm/gkm-session.h"
      33              : #include "gkm/gkm-transaction.h"
      34              : 
      35              : #include "pkcs11/pkcs11i.h"
      36              : 
      37              : #include <glib.h>
      38              : 
      39              : #include <stdlib.h>
      40              : #include <stdio.h>
      41              : #include <string.h>
      42              : 
      43              : typedef struct {
      44              :         GkmModule *module;
      45              :         GkmSession *session;
      46              :         CK_OBJECT_HANDLE credential;
      47              :         CK_OBJECT_HANDLE credential2;
      48              :         GkmSecretCollection *collection;
      49              : } Test;
      50              : 
      51              : static void
      52           20 : setup (Test *test, gconstpointer unused)
      53              : {
      54           20 :         CK_OBJECT_CLASS klass = CKO_G_CREDENTIAL;
      55              :         GkmObject *cred;
      56              : 
      57           20 :         CK_ATTRIBUTE attrs[] = {
      58              :                 { CKA_CLASS, &klass, sizeof (klass) },
      59              :                 { CKA_VALUE, NULL, 0 }
      60              :         };
      61              : 
      62           20 :         test->module = test_secret_module_initialize_and_enter ();
      63           20 :         test->session = test_secret_module_open_session (TRUE);
      64              : 
      65           20 :         test->collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
      66              :                                    "module", test->module,
      67              :                                    "identifier", "test",
      68              :                                    NULL);
      69           20 :         g_assert (GKM_IS_SECRET_COLLECTION (test->collection));
      70              : 
      71              :         /* Make two credentials */
      72           20 :         cred = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_CREDENTIAL, NULL,
      73              :                                                     attrs, G_N_ELEMENTS (attrs));
      74           20 :         g_assert (cred != NULL);
      75           20 :         test->credential = gkm_object_get_handle (GKM_OBJECT (cred));
      76           20 :         g_object_unref (cred);
      77              : 
      78           20 :         cred = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_CREDENTIAL, NULL,
      79              :                                                     attrs, G_N_ELEMENTS (attrs));
      80           20 :         g_assert (cred != NULL);
      81           20 :         test->credential2 = gkm_object_get_handle (GKM_OBJECT (cred));
      82           20 :         g_object_unref (cred);
      83           20 : }
      84              : 
      85              : static void
      86           20 : teardown (Test *test, gconstpointer unused)
      87              : {
      88           20 :         if (test->collection)
      89           20 :                 g_object_unref (test->collection);
      90           20 :         test->collection = NULL;
      91              : 
      92           20 :         test_secret_module_leave_and_finalize ();
      93           20 :         test->module = NULL;
      94           20 :         test->session = NULL;
      95           20 :         test->credential = 0;
      96           20 : }
      97              : 
      98              : static void
      99            1 : test_is_locked (Test *test, gconstpointer unused)
     100              : {
     101              :         gboolean locked;
     102              : 
     103              :         /* By default is locked */
     104            1 :         locked = gkm_secret_object_is_locked (GKM_SECRET_OBJECT (test->collection), test->session);
     105            1 :         g_assert (locked == TRUE);
     106            1 : }
     107              : 
     108              : static void
     109            1 : test_unlocked_data (Test *test, gconstpointer unused)
     110              : {
     111              :         GkmCredential *cred;
     112              :         GkmSecretData *sdata;
     113              :         CK_RV rv;
     114              : 
     115              :         /* Create test->credential, which unlocks test->collection */
     116            1 :         rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection), NULL, 0, &cred);
     117            1 :         g_assert (rv == CKR_OK);
     118            1 :         gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
     119            1 :         g_object_unref (cred);
     120              : 
     121              :         /* Collection should now be unlocked */
     122            1 :         sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
     123            1 :         g_assert (GKM_IS_SECRET_DATA (sdata));
     124            1 :         g_assert (!gkm_secret_object_is_locked (GKM_SECRET_OBJECT (test->collection), test->session));
     125            1 :         g_object_unref (sdata);
     126            1 : }
     127              : 
     128              : static void
     129            1 : test_get_filename (Test *test, gconstpointer unused)
     130              : {
     131              :         GkmSecretCollection *other;
     132              :         const gchar *filename;
     133              : 
     134            1 :         other = g_object_new (GKM_TYPE_SECRET_COLLECTION,
     135              :                               "module", test->module,
     136              :                               "identifier", "test",
     137              :                               "filename", "/tmp/filename.keyring",
     138              :                               NULL);
     139              : 
     140            1 :         filename = gkm_secret_collection_get_filename (other);
     141            1 :         g_assert_cmpstr (filename, ==, "/tmp/filename.keyring");
     142              : 
     143            1 :         g_object_unref (other);
     144            1 : }
     145              : 
     146              : static void
     147            1 : test_set_filename (Test *test, gconstpointer unused)
     148              : {
     149              :         const gchar *filename;
     150              : 
     151            1 :         gkm_secret_collection_set_filename (test->collection, "/tmp/filename.keyring");
     152              : 
     153            1 :         filename = gkm_secret_collection_get_filename (test->collection);
     154            1 :         g_assert_cmpstr (filename, ==, "/tmp/filename.keyring");
     155            1 : }
     156              : 
     157              : static void
     158            1 : test_has_item (Test *test, gconstpointer unused)
     159              : {
     160              :         GkmSecretItem *item;
     161              : 
     162            1 :         item = gkm_secret_collection_new_item (test->collection, "testo");
     163            1 :         g_assert (gkm_secret_collection_has_item (test->collection, item));
     164            1 : }
     165              : 
     166              : static void
     167            1 : test_load_unlock_plain (Test *test, gconstpointer unused)
     168              : {
     169              :         GkmCredential *cred;
     170              :         GkmSecretData *sdata;
     171              :         GkmDataResult res;
     172              :         CK_RV rv;
     173              : 
     174            1 :         gkm_secret_collection_set_filename (test->collection, SRCDIR "/pkcs11/secret-store/fixtures/plain.keyring");
     175              : 
     176              :         /* Load the data in the file */
     177            1 :         res = gkm_secret_collection_load (test->collection);
     178            1 :         g_assert (res == GKM_DATA_SUCCESS);
     179              : 
     180              :         /* Unlock the keyring, which should load again */
     181            1 :         rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection), NULL, 0, &cred);
     182            1 :         g_assert (rv == CKR_OK);
     183            1 :         gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
     184            1 :         g_object_unref (cred);
     185              : 
     186            1 :         sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
     187            1 :         g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
     188            1 :         test_secret_collection_validate (test->collection, sdata);
     189            1 :         g_object_unref (sdata);
     190            1 : }
     191              : 
     192              : static void
     193            1 : test_load_unlock_encrypted (Test *test, gconstpointer unused)
     194              : {
     195              :         GkmCredential *cred;
     196              :         GkmSecretData *sdata;
     197              :         GkmDataResult res;
     198              :         CK_RV rv;
     199              : 
     200            1 :         gkm_secret_collection_set_filename (test->collection, SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring");
     201              : 
     202              :         /* Load the data in the file */
     203            1 :         res = gkm_secret_collection_load (test->collection);
     204            1 :         g_assert (res == GKM_DATA_SUCCESS);
     205              : 
     206              :         /* Unlock the keyring, which should load again */
     207            1 :         rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
     208              :                                     (guchar*)"my-keyring-password", 19, &cred);
     209            1 :         g_assert (rv == CKR_OK);
     210            1 :         gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
     211            1 :         g_object_unref (cred);
     212              : 
     213            1 :         sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
     214            1 :         g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
     215            1 :         test_secret_collection_validate (test->collection, sdata);
     216            1 :         g_object_unref (sdata);
     217            1 : }
     218              : 
     219              : static void
     220            1 : test_load_unlock_bad_password (Test *test, gconstpointer unused)
     221              : {
     222              :         GkmCredential *cred;
     223              :         GkmDataResult res;
     224              :         CK_RV rv;
     225              : 
     226            1 :         gkm_secret_collection_set_filename (test->collection, SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring");
     227              : 
     228              :         /* Load the data in the file */
     229            1 :         res = gkm_secret_collection_load (test->collection);
     230            1 :         g_assert (res == GKM_DATA_SUCCESS);
     231              : 
     232              :         /* Unlock the keyring, which should load again */
     233            1 :         rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
     234              :                                     (guchar*)"wrong", 5, &cred);
     235            1 :         g_assert (rv == CKR_PIN_INCORRECT);
     236            1 : }
     237              : 
     238              : static void
     239            1 : test_unlock_without_load (Test *test, gconstpointer unused)
     240              : {
     241              :         GkmCredential *cred;
     242              :         GkmSecretData *sdata;
     243              :         CK_RV rv;
     244              : 
     245            1 :         gkm_secret_collection_set_filename (test->collection, SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring");
     246              : 
     247              :         /* Unlock the keyring, which should load it */
     248            1 :         rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
     249              :                                     (guchar*)"my-keyring-password", 19, &cred);
     250            1 :         g_assert (rv == CKR_OK);
     251            1 :         gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
     252            1 :         g_object_unref (cred);
     253              : 
     254            1 :         sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
     255            1 :         g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
     256            1 :         test_secret_collection_validate (test->collection, sdata);
     257            1 :         g_object_unref (sdata);
     258            1 : }
     259              : 
     260              : static void
     261            1 : test_twice_unlock (Test *test, gconstpointer unused)
     262              : {
     263              :         GkmCredential *cred;
     264              :         GkmSecretData *sdata;
     265              :         CK_RV rv;
     266              : 
     267            1 :         gkm_secret_collection_set_filename (test->collection, SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring");
     268              : 
     269              :         /* Unlock the keyring, which should load */
     270            1 :         rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
     271              :                                     (guchar*)"my-keyring-password", 19, &cred);
     272            1 :         g_assert (rv == CKR_OK);
     273            1 :         gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
     274            1 :         g_object_unref (cred);
     275              : 
     276              :         /* Unlock the keyring again, which should not reload */
     277            1 :         rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
     278              :                                     (guchar*)"my-keyring-password", 19, &cred);
     279            1 :         g_assert (rv == CKR_OK);
     280            1 :         gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
     281            1 :         g_object_unref (cred);
     282              : 
     283            1 :         sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
     284            1 :         g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
     285            1 :         test_secret_collection_validate (test->collection, sdata);
     286            1 :         g_object_unref (sdata);
     287            1 : }
     288              : 
     289              : static void
     290            1 : test_twice_unlock_bad_password (Test *test, gconstpointer unused)
     291              : {
     292              :         GkmCredential *cred;
     293              :         GkmSecretData *sdata;
     294              :         CK_RV rv;
     295              : 
     296            1 :         gkm_secret_collection_set_filename (test->collection, SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring");
     297              : 
     298              :         /* Unlock the keyring, which should load */
     299            1 :         rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
     300              :                                        (guchar*)"my-keyring-password", 19, &cred);
     301            1 :         g_assert (rv == CKR_OK);
     302            1 :         gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
     303            1 :         g_object_unref (cred);
     304              : 
     305              :         /* Unlock the keyring again, wrong password */
     306            1 :         rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
     307              :                                     (guchar*)"wrong", 5, &cred);
     308            1 :         g_assert (rv == CKR_PIN_INCORRECT);
     309              : 
     310            1 :         sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
     311            1 :         g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
     312            1 :         test_secret_collection_validate (test->collection, sdata);
     313            1 :         g_object_unref (sdata);
     314            1 : }
     315              : 
     316              : static void
     317            1 : test_memory_unlock (Test *test, gconstpointer unused)
     318              : {
     319              :         GkmCredential *cred;
     320              :         GkmDataResult res;
     321              :         CK_RV rv;
     322              : 
     323              :         /* Load the data in the file */
     324            1 :         res = gkm_secret_collection_load (test->collection);
     325            1 :         g_assert (res == GKM_DATA_SUCCESS);
     326              : 
     327              :         /* Unlock the keyring, which should load again */
     328            1 :         rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
     329              :                                     NULL, 0, &cred);
     330            1 :         g_assert (rv == CKR_OK);
     331            1 :         gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
     332            1 :         g_object_unref (cred);
     333            1 : }
     334              : 
     335              : static void
     336            1 : test_memory_unlock_bad_password (Test *test, gconstpointer unused)
     337              : {
     338              :         GkmCredential *cred;
     339              :         GkmDataResult res;
     340              :         CK_RV rv;
     341              : 
     342              :         /* Load the data in the file */
     343            1 :         res = gkm_secret_collection_load (test->collection);
     344            1 :         g_assert (res == GKM_DATA_SUCCESS);
     345              : 
     346              :         /* Unlock the keyring, which should load again */
     347            1 :         rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
     348              :                                     (guchar*)"wrong", 5, &cred);
     349            1 :         g_assert (rv == CKR_PIN_INCORRECT);
     350            1 : }
     351              : 
     352              : static void
     353            1 : test_factory (Test *test, gconstpointer unused)
     354              : {
     355            1 :         CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
     356              :         GkmObject *object;
     357              : 
     358            1 :         CK_ATTRIBUTE attrs[] = {
     359              :                 { CKA_CLASS, &klass, sizeof (klass) },
     360              :                 { CKA_LABEL, "blah", 4 },
     361            1 :                 { CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
     362              :         };
     363              : 
     364            1 :         object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
     365              :                                                         attrs, G_N_ELEMENTS (attrs));
     366            1 :         g_assert (object != NULL);
     367            1 :         g_assert (GKM_IS_SECRET_COLLECTION (object));
     368              : 
     369            1 :         g_assert_cmpstr (gkm_secret_object_get_label (GKM_SECRET_OBJECT (object)), ==, "blah");
     370            1 :         g_object_unref (object);
     371            1 : }
     372              : 
     373              : static void
     374            1 : test_factory_unnamed (Test *test, gconstpointer unused)
     375              : {
     376            1 :         CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
     377              :         const gchar *identifier;
     378              :         GkmObject *object;
     379              : 
     380            1 :         CK_ATTRIBUTE attrs[] = {
     381              :                 { CKA_CLASS, &klass, sizeof (klass) },
     382            1 :                 { CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
     383              :         };
     384              : 
     385            1 :         object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
     386              :                                                         attrs, G_N_ELEMENTS (attrs));
     387            1 :         g_assert (object != NULL);
     388            1 :         g_assert (GKM_IS_SECRET_COLLECTION (object));
     389              : 
     390            1 :         identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
     391            1 :         g_assert_cmpstr (identifier, !=, "");
     392            1 :         g_object_unref (object);
     393            1 : }
     394              : 
     395              : static void
     396            1 : test_factory_token (Test *test, gconstpointer unused)
     397              : {
     398            1 :         CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
     399              :         const gchar *identifier;
     400              :         GkmObject *object;
     401            1 :         CK_BBOOL token = CK_TRUE;
     402              : 
     403            1 :         CK_ATTRIBUTE attrs[] = {
     404              :                 { CKA_CLASS, &klass, sizeof (klass) },
     405              :                 { CKA_TOKEN, &token, sizeof (token) },
     406              :                 { CKA_LABEL, "blah", 4 },
     407            1 :                 { CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
     408              :         };
     409              : 
     410            1 :         object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
     411              :                                                         attrs, G_N_ELEMENTS (attrs));
     412            1 :         g_assert (object != NULL);
     413            1 :         g_assert (GKM_IS_SECRET_COLLECTION (object));
     414              : 
     415            1 :         identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
     416            1 :         g_assert (strstr (identifier, "blah"));
     417            1 :         g_object_unref (object);
     418            1 : }
     419              : 
     420              : static void
     421            1 : test_factory_duplicate (Test *test, gconstpointer unused)
     422              : {
     423            1 :         CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
     424              :         const gchar *identifier1, *identifier2;
     425              :         GkmObject *object;
     426              : 
     427            1 :         CK_ATTRIBUTE attrs[] = {
     428            1 :                 { CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
     429              :                 { CKA_CLASS, &klass, sizeof (klass) },
     430              :                 { CKA_LABEL, "blah", 4 },
     431              :         };
     432              : 
     433            1 :         object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
     434              :                                                         attrs, G_N_ELEMENTS (attrs));
     435            1 :         g_assert (object != NULL);
     436            1 :         g_assert (GKM_IS_SECRET_COLLECTION (object));
     437              : 
     438            1 :         identifier1 = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
     439            1 :         g_assert (strstr (identifier1, "blah"));
     440            1 :         g_object_unref (object);
     441              : 
     442              :         /* Use second test->credential for second object */
     443            1 :         attrs[0].pValue = &test->credential2;
     444            1 :         object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
     445              :                                                         attrs, G_N_ELEMENTS (attrs));
     446            1 :         g_assert (object != NULL);
     447            1 :         g_assert (GKM_IS_SECRET_COLLECTION (object));
     448              : 
     449            1 :         identifier2 = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
     450            1 :         g_assert (strstr (identifier2, "blah"));
     451            1 :         g_object_unref (object);
     452              : 
     453            1 :         g_assert_cmpstr (identifier1, !=, identifier2);
     454            1 : }
     455              : 
     456              : static void
     457            1 : test_factory_item (Test *test, gconstpointer unused)
     458              : {
     459            1 :         CK_OBJECT_CLASS c_klass = CKO_G_COLLECTION;
     460            1 :         CK_OBJECT_CLASS i_klass = CKO_SECRET_KEY;
     461              :         const gchar *identifier;
     462              :         GkmObject *object;
     463            1 :         CK_BBOOL token = CK_TRUE;
     464              : 
     465            1 :         CK_ATTRIBUTE c_attrs[] = {
     466              :                 { CKA_CLASS, &c_klass, sizeof (c_klass) },
     467              :                 { CKA_TOKEN, &token, sizeof (token) },
     468              :                 { CKA_LABEL, "three", 5 },
     469            1 :                 { CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
     470              :         };
     471              : 
     472            1 :         CK_ATTRIBUTE i_attrs[] = {
     473              :                 { CKA_G_COLLECTION, NULL, 0 }, /* Filled below */
     474              :                 { CKA_CLASS, &i_klass, sizeof (i_klass) },
     475              :                 { CKA_TOKEN, &token, sizeof (token) },
     476              :                 { CKA_LABEL, "Item", 4 },
     477              :         };
     478              : 
     479            1 :         object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
     480              :                                                         c_attrs, G_N_ELEMENTS (c_attrs));
     481            1 :         g_assert (object != NULL);
     482            1 :         g_assert (GKM_IS_SECRET_COLLECTION (object));
     483            1 :         identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
     484            1 :         g_object_unref (object);
     485              : 
     486            1 :         i_attrs[0].pValue = (gpointer)identifier;
     487            1 :         i_attrs[0].ulValueLen = strlen (identifier);
     488            1 :         object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_ITEM, NULL,
     489              :                                                         i_attrs, G_N_ELEMENTS (i_attrs));
     490            1 :         g_assert (object != NULL);
     491            1 :         g_assert (GKM_IS_SECRET_ITEM (object));
     492            1 :         g_object_unref (object);
     493            1 : }
     494              : 
     495              : static void
     496            1 : test_token_remove (Test *test, gconstpointer unused)
     497              : {
     498            1 :         CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
     499              :         GkmTransaction *transaction;
     500              :         GkmObject *object;
     501            1 :         CK_BBOOL token = CK_TRUE;
     502              : 
     503            1 :         CK_ATTRIBUTE attrs[] = {
     504              :                 { CKA_CLASS, &klass, sizeof (klass) },
     505              :                 { CKA_TOKEN, &token, sizeof (token) },
     506              :                 { CKA_LABEL, "blah", 4 },
     507            1 :                 { CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
     508              :         };
     509              : 
     510            1 :         object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
     511              :                                                         attrs, G_N_ELEMENTS (attrs));
     512            1 :         g_assert (object != NULL);
     513            1 :         g_assert (GKM_IS_SECRET_COLLECTION (object));
     514              : 
     515            1 :         transaction = gkm_transaction_new ();
     516            1 :         gkm_module_remove_token_object (test->module, transaction, object);
     517            1 :         g_assert (!gkm_transaction_get_failed (transaction));
     518            1 :         gkm_transaction_complete (transaction);
     519            1 :         g_object_unref (transaction);
     520            1 :         g_object_unref (object);
     521            1 : }
     522              : 
     523              : static void
     524            1 : test_token_item_remove (Test *test, gconstpointer unused)
     525              : {
     526            1 :         CK_OBJECT_CLASS c_klass = CKO_G_COLLECTION;
     527            1 :         CK_OBJECT_CLASS i_klass = CKO_SECRET_KEY;
     528              :         GkmTransaction *transaction;
     529              :         const gchar *identifier;
     530              :         GkmObject *object;
     531            1 :         CK_BBOOL token = CK_TRUE;
     532              : 
     533            1 :         CK_ATTRIBUTE c_attrs[] = {
     534              :                 { CKA_CLASS, &c_klass, sizeof (c_klass) },
     535              :                 { CKA_TOKEN, &token, sizeof (token) },
     536              :                 { CKA_LABEL, "three", 5 },
     537            1 :                 { CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
     538              :         };
     539              : 
     540            1 :         CK_ATTRIBUTE i_attrs[] = {
     541              :                 { CKA_G_COLLECTION, NULL, 0 }, /* Filled below */
     542              :                 { CKA_CLASS, &i_klass, sizeof (i_klass) },
     543              :                 { CKA_TOKEN, &token, sizeof (token) },
     544              :                 { CKA_LABEL, "Item", 4 },
     545              :         };
     546              : 
     547            1 :         object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
     548              :                                                         c_attrs, G_N_ELEMENTS (c_attrs));
     549            1 :         g_assert (object != NULL);
     550            1 :         g_assert (GKM_IS_SECRET_COLLECTION (object));
     551            1 :         identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
     552            1 :         g_object_unref (object);
     553              : 
     554            1 :         i_attrs[0].pValue = (gpointer)identifier;
     555            1 :         i_attrs[0].ulValueLen = strlen (identifier);
     556            1 :         object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_ITEM, NULL,
     557              :                                                         i_attrs, G_N_ELEMENTS (i_attrs));
     558            1 :         g_assert (object != NULL);
     559            1 :         g_assert (GKM_IS_SECRET_ITEM (object));
     560              : 
     561            1 :         transaction = gkm_transaction_new ();
     562            1 :         gkm_module_remove_token_object (test->module, transaction, object);
     563            1 :         g_assert (!gkm_transaction_get_failed (transaction));
     564            1 :         gkm_transaction_complete (transaction);
     565            1 :         g_object_unref (transaction);
     566            1 :         g_object_unref (object);
     567            1 : }
     568              : 
     569              : int
     570            1 : main (int argc, char **argv)
     571              : {
     572              : #if !GLIB_CHECK_VERSION(2,35,0)
     573              :         g_type_init ();
     574              : #endif
     575            1 :         g_test_init (&argc, &argv, NULL);
     576              : 
     577            1 :         g_test_add ("/secret-store/collection/is_locked", Test, NULL, setup, test_is_locked, teardown);
     578            1 :         g_test_add ("/secret-store/collection/unlocked_data", Test, NULL, setup, test_unlocked_data, teardown);
     579            1 :         g_test_add ("/secret-store/collection/get_filename", Test, NULL, setup, test_get_filename, teardown);
     580            1 :         g_test_add ("/secret-store/collection/set_filename", Test, NULL, setup, test_set_filename, teardown);
     581            1 :         g_test_add ("/secret-store/collection/has_item", Test, NULL, setup, test_has_item, teardown);
     582            1 :         g_test_add ("/secret-store/collection/load_unlock_plain", Test, NULL, setup, test_load_unlock_plain, teardown);
     583            1 :         g_test_add ("/secret-store/collection/load_unlock_encrypted", Test, NULL, setup, test_load_unlock_encrypted, teardown);
     584            1 :         g_test_add ("/secret-store/collection/load_unlock_bad_password", Test, NULL, setup, test_load_unlock_bad_password, teardown);
     585            1 :         g_test_add ("/secret-store/collection/unlock_without_load", Test, NULL, setup, test_unlock_without_load, teardown);
     586            1 :         g_test_add ("/secret-store/collection/twice_unlock", Test, NULL, setup, test_twice_unlock, teardown);
     587            1 :         g_test_add ("/secret-store/collection/twice_unlock_bad_password", Test, NULL, setup, test_twice_unlock_bad_password, teardown);
     588            1 :         g_test_add ("/secret-store/collection/memory_unlock", Test, NULL, setup, test_memory_unlock, teardown);
     589            1 :         g_test_add ("/secret-store/collection/memory_unlock_bad_password", Test, NULL, setup, test_memory_unlock_bad_password, teardown);
     590            1 :         g_test_add ("/secret-store/collection/factory", Test, NULL, setup, test_factory, teardown);
     591            1 :         g_test_add ("/secret-store/collection/factory_unnamed", Test, NULL, setup, test_factory_unnamed, teardown);
     592            1 :         g_test_add ("/secret-store/collection/factory_token", Test, NULL, setup, test_factory_token, teardown);
     593            1 :         g_test_add ("/secret-store/collection/factory_duplicate", Test, NULL, setup, test_factory_duplicate, teardown);
     594            1 :         g_test_add ("/secret-store/collection/factory_item", Test, NULL, setup, test_factory_item, teardown);
     595            1 :         g_test_add ("/secret-store/collection/token_remove", Test, NULL, setup, test_token_remove, teardown);
     596            1 :         g_test_add ("/secret-store/collection/token_item_remove", Test, NULL, setup, test_token_item_remove, teardown);
     597              : 
     598            1 :         return g_test_run ();
     599              : }
        

Generated by: LCOV version 2.0-1