efl

1
#ifdef HAVE_CONFIG_H
2
# include "config.h"
3
#endif
4

5
#include <stdlib.h>
6
#include <unistd.h>
7
#include <fcntl.h>
8

9
#include <Eina.h>
10
#include <Eet.h>
11

12
#include "eet_suite.h"
13
#include "eet_test_common.h"
14

15
#ifndef O_BINARY
16
# define O_BINARY 0
17
#endif
18

19
static char _key_pem[PATH_MAX] = "";
20
static char _cert_pem[PATH_MAX] = "";
21
static char _key_enc[PATH_MAX] = "";
22
static char _key_enc_pem[PATH_MAX] = "";
23
static char _key_enc_none_pem[PATH_MAX] = "";
24

25
static int
26
pass_get(char            *pass,
27
         int              size,
28
         EINA_UNUSED int   rwflags,
29
         EINA_UNUSED void *u)
30
{
31
   memset(pass, 0, size);
32

33
   if ((int)strlen("password") > size)
34
     return 0;
35

36
   snprintf(pass, size, "%s", "password");
37
   return strlen(pass);
38
}
39

40
static int
41
badpass_get(char            *pass,
42
            int              size,
43
            EINA_UNUSED int   rwflags,
44
            EINA_UNUSED void *u)
45
{
46
   memset(pass, 0, size);
47

48
   if ((int)strlen("bad password") > size)
49
     return 0;
50

51
   snprintf(pass, size, "%s", "bad password");
52
   return strlen(pass);
53
}
54

55
EFL_START_TEST(eet_test_identity_simple)
56
{
57
   const char *buffer = "Here is a string of data to save !";
58
   const void *tmp;
59
   Eet_File *ef;
60
   Eet_Key *k;
61
   FILE *noread;
62
   char *test;
63
   int size;
64
   int fd;
65
   Eina_Tmpstr *tmpf = NULL;
66

67
   fail_if(-1 == (fd = eina_file_mkstemp("eet_suite_testXXXXXX", &tmpf)));
68
   fail_if(!!close(fd));
69
   fail_if(!(noread = fopen("/dev/null", "wb")));
70

71
   /* Sign an eet file. */
72
   ef = eet_open(tmpf, EET_FILE_MODE_WRITE);
73
   fail_if(!ef);
74

75
   fail_if(!eet_write(ef, "keys/tests", buffer, strlen(buffer) + 1, 0));
76

77
   k = eet_identity_open(_cert_pem, _key_pem, NULL);
78
   fail_if(!k);
79

80
   fail_if(eet_identity_set(ef, k) != EET_ERROR_NONE);
81
   eet_identity_print(k, noread);
82

83
   eet_close(ef);
84

85
   /* Open a signed file. */
86
   ef = eet_open(tmpf, EET_FILE_MODE_READ);
87
   fail_if(!ef);
88

89
   /* check that the certificates match */
90
   fail_if(!eet_identity_verify(ef, _cert_pem));
91

92
   test = eet_read(ef, "keys/tests", &size);
93
   fail_if(!test);
94
   fail_if(size != (int)strlen(buffer) + 1);
95

96
   fail_if(memcmp(test, buffer, strlen(buffer) + 1) != 0);
97

98
   tmp = eet_identity_x509(ef, &size);
99
   fail_if(tmp == NULL);
100

101
   eet_identity_certificate_print(tmp, size, noread);
102

103
   eet_close(ef);
104

105
   /* As we are changing file contain in less than 1s, this could get unnoticed
106
      by eet cache system. */
107
   eet_clearcache();
108

109
   /* Corrupting the file. */
110
   fd = open(tmpf, O_WRONLY | O_BINARY);
111
   fail_if(fd < 0);
112

113
   fail_if(lseek(fd, 200, SEEK_SET) != 200);
114
   fail_if(write(fd, "42", 2) != 2);
115
   fail_if(lseek(fd, 50, SEEK_SET) != 50);
116
   fail_if(write(fd, "42", 2) != 2);
117
   fail_if(lseek(fd, 88, SEEK_SET) != 88);
118
   fail_if(write(fd, "42", 2) != 2);
119

120
   close(fd);
121

122
   /* Attempt to open a modified file. */
123
   ef = eet_open(tmpf, EET_FILE_MODE_READ);
124
   fail_if(ef);
125

126
   fail_if(unlink(tmpf) != 0);
127

128
   eina_tmpstr_del(tmpf);
129
}
130
EFL_END_TEST
131

132
EFL_START_TEST(eet_test_identity_open_simple)
133
{
134
   Eet_Key *k = NULL;
135

136
   k = eet_identity_open(_cert_pem, _key_pem, NULL);
137
   fail_if(!k);
138

139
   if (k)
140
     eet_identity_close(k);
141

142
}
143
EFL_END_TEST
144

145
EFL_START_TEST(eet_test_identity_open_pkcs8)
146
{
147
   Eet_Key *k = NULL;
148

149
   k = eet_identity_open(_cert_pem, _key_enc_none_pem, NULL);
150
   fail_if(!k);
151

152
   if (k)
153
     eet_identity_close(k);
154

155
}
156
EFL_END_TEST
157

158
static int
159
pw_cb(char *buf EINA_UNUSED, int size EINA_UNUSED, int rwflag EINA_UNUSED, void *data EINA_UNUSED)
160
{
161
   return 0;
162
}
163

164
EFL_START_TEST(eet_test_identity_open_pkcs8_enc)
165
{
166
   Eet_Key *k = NULL;
167

168
   k = eet_identity_open(_cert_pem, _key_enc_pem, pw_cb);
169
   fail_if(k);
170

171
   if (k)
172
     eet_identity_close(k);
173

174
   k = eet_identity_open(_cert_pem, _key_enc_pem, &badpass_get);
175
   fail_if(k);
176

177
   if (k)
178
     eet_identity_close(k);
179

180
   k = eet_identity_open(_cert_pem, _key_enc_pem, &pass_get);
181
   fail_if(!k);
182

183
   if (k)
184
     eet_identity_close(k);
185

186
}
187
EFL_END_TEST
188

189
static const char *_cert_dir_find(const char *_argv0)
190
{
191
   static char base[PATH_MAX] = "";
192
   char path[PATH_MAX];
193
   struct stat st;
194

195
   eina_strlcpy(base, TESTS_SRC_DIR, sizeof(base));
196
   eina_str_join(path, sizeof(path), '/', base, "key.pem");
197
   if (stat(path, &st) == 0)
198
     return base;
199

200
   if (base[0] != '/')
201
     {
202
        snprintf(base, sizeof(base), "%s/%s", TESTS_WD, TESTS_SRC_DIR);
203
        eina_str_join(path, sizeof(path), '/', base, "key.pem");
204
        if (stat(path, &st) == 0)
205
          return base;
206
     }
207

208
   eina_strlcpy(base, _argv0, sizeof(base));
209
   do
210
     {
211
        char *p = strrchr(base, '/');
212
        if (!p)
213
          {
214
             base[0] = '\0';
215
             break;
216
          }
217
        *p = '\0';
218
        eina_str_join(path, sizeof(path), '/', base, "key.pem");
219
     }
220
   while (stat(path, &st) != 0);
221

222
   return base;
223
}
224

225
void eet_test_identity(TCase *tc)
226
{
227
   const char *base;
228

229
   base = _cert_dir_find(argv0);
230
   eina_str_join(_key_pem, sizeof(_key_pem), '/', base, "key.pem");
231
   eina_str_join(_cert_pem, sizeof(_cert_pem), '/', base,"cert.pem");
232
   eina_str_join(_key_enc, sizeof(_key_enc), '/', base, "key.enc");
233
   eina_str_join(_key_enc_pem, sizeof(_key_enc_pem), '/', base, "key_enc.pem");
234
   eina_str_join(_key_enc_none_pem, sizeof(_key_enc_none_pem), '/',
235
                 base, "key_enc_none.pem");
236

237
   tcase_add_test(tc, eet_test_identity_simple);
238
   tcase_add_test(tc, eet_test_identity_open_simple);
239
   tcase_add_test(tc, eet_test_identity_open_pkcs8);
240
   tcase_add_test(tc, eet_test_identity_open_pkcs8_enc);
241
}
242