diff options
Diffstat (limited to 'src/include')
-rw-r--r-- | src/include/gnunet_credential_service.h | 308 | ||||
-rw-r--r-- | src/include/gnunet_crypto_lib.h | 82 | ||||
-rw-r--r-- | src/include/gnunet_gnsrecord_lib.h | 22 | ||||
-rw-r--r-- | src/include/gnunet_identity_attribute_lib.h | 277 | ||||
-rw-r--r-- | src/include/gnunet_identity_attribute_plugin.h | 149 | ||||
-rw-r--r-- | src/include/gnunet_identity_provider_plugin.h | 123 | ||||
-rw-r--r-- | src/include/gnunet_identity_provider_service.h | 332 | ||||
-rw-r--r-- | src/include/gnunet_jsonapi_lib.h | 2 | ||||
-rw-r--r-- | src/include/gnunet_protocols.h | 42 | ||||
-rw-r--r-- | src/include/gnunet_signatures.h | 5 |
10 files changed, 1199 insertions, 143 deletions
diff --git a/src/include/gnunet_credential_service.h b/src/include/gnunet_credential_service.h index 9e765c12b..67c2f2b4c 100644 --- a/src/include/gnunet_credential_service.h +++ b/src/include/gnunet_credential_service.h | |||
@@ -20,6 +20,7 @@ | |||
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @author Martin Schanzenbach | 22 | * @author Martin Schanzenbach |
23 | * @author Adnan Husain | ||
23 | * | 24 | * |
24 | * @file | 25 | * @file |
25 | * API to the Credential service | 26 | * API to the Credential service |
@@ -34,6 +35,7 @@ | |||
34 | 35 | ||
35 | #include "gnunet_util_lib.h" | 36 | #include "gnunet_util_lib.h" |
36 | #include "gnunet_gns_service.h" | 37 | #include "gnunet_gns_service.h" |
38 | #include "gnunet_identity_service.h" | ||
37 | 39 | ||
38 | #ifdef __cplusplus | 40 | #ifdef __cplusplus |
39 | extern "C" | 41 | extern "C" |
@@ -52,7 +54,157 @@ struct GNUNET_CREDENTIAL_Handle; | |||
52 | /** | 54 | /** |
53 | * Handle to control a lookup operation. | 55 | * Handle to control a lookup operation. |
54 | */ | 56 | */ |
55 | struct GNUNET_CREDENTIAL_LookupRequest; | 57 | struct GNUNET_CREDENTIAL_Request; |
58 | |||
59 | /* | ||
60 | * Enum used for checking whether the issuer has the authority to issue credentials or is just a subject | ||
61 | */ | ||
62 | enum GNUNET_CREDENTIAL_CredentialFlags { | ||
63 | |||
64 | //Subject had credentials before, but have been revoked now | ||
65 | GNUNET_CREDENTIAL_FLAG_REVOKED=0, | ||
66 | |||
67 | //Subject flag indicates that the subject is a holder of this credential and may present it as such | ||
68 | GNUNET_CREDENTIAL_FLAG_SUBJECT=1, | ||
69 | |||
70 | //Issuer flag is used to signify that the subject is allowed to issue this credential and delegate issuance | ||
71 | GNUNET_CREDENTIAL_FLAG_ISSUER=2 | ||
72 | |||
73 | }; | ||
74 | |||
75 | GNUNET_NETWORK_STRUCT_BEGIN | ||
76 | /** | ||
77 | * The attribute delegation record | ||
78 | */ | ||
79 | struct GNUNET_CREDENTIAL_DelegationRecord { | ||
80 | |||
81 | /** | ||
82 | * Number of delegation sets in this record | ||
83 | */ | ||
84 | uint32_t set_count; | ||
85 | |||
86 | /** | ||
87 | * Length of delegation sets | ||
88 | */ | ||
89 | uint64_t data_size; | ||
90 | /** | ||
91 | * Followed by set_count DelegationSetRecords | ||
92 | * | ||
93 | */ | ||
94 | }; | ||
95 | |||
96 | /** | ||
97 | * The attribute delegation record | ||
98 | */ | ||
99 | struct GNUNET_CREDENTIAL_DelegationRecordSet { | ||
100 | |||
101 | /** | ||
102 | * Public key of the subject this attribute was delegated to | ||
103 | */ | ||
104 | struct GNUNET_CRYPTO_EcdsaPublicKey subject_key; | ||
105 | |||
106 | /** | ||
107 | * Length of attribute, may be 0 | ||
108 | */ | ||
109 | uint32_t subject_attribute_len; | ||
110 | }; | ||
111 | |||
112 | |||
113 | GNUNET_NETWORK_STRUCT_END | ||
114 | |||
115 | /** | ||
116 | * The attribute delegation record | ||
117 | */ | ||
118 | struct GNUNET_CREDENTIAL_DelegationSet { | ||
119 | |||
120 | /** | ||
121 | * Public key of the subject this attribute was delegated to | ||
122 | */ | ||
123 | struct GNUNET_CRYPTO_EcdsaPublicKey subject_key; | ||
124 | |||
125 | uint32_t subject_attribute_len; | ||
126 | |||
127 | /** | ||
128 | * The subject attribute | ||
129 | */ | ||
130 | const char *subject_attribute; | ||
131 | }; | ||
132 | |||
133 | |||
134 | /** | ||
135 | * A delegation | ||
136 | */ | ||
137 | struct GNUNET_CREDENTIAL_Delegation { | ||
138 | |||
139 | /** | ||
140 | * The issuer of the delegation | ||
141 | */ | ||
142 | struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key; | ||
143 | |||
144 | /** | ||
145 | * Public key of the subject this attribute was delegated to | ||
146 | */ | ||
147 | struct GNUNET_CRYPTO_EcdsaPublicKey subject_key; | ||
148 | |||
149 | /** | ||
150 | * Length of the attribute | ||
151 | */ | ||
152 | uint32_t issuer_attribute_len; | ||
153 | |||
154 | /** | ||
155 | * The attribute | ||
156 | */ | ||
157 | const char *issuer_attribute; | ||
158 | |||
159 | /** | ||
160 | * Length of the attribute | ||
161 | */ | ||
162 | uint32_t subject_attribute_len; | ||
163 | |||
164 | /** | ||
165 | * The attribute | ||
166 | */ | ||
167 | const char *subject_attribute; | ||
168 | }; | ||
169 | |||
170 | |||
171 | /** | ||
172 | * A credential | ||
173 | */ | ||
174 | struct GNUNET_CREDENTIAL_Credential { | ||
175 | |||
176 | /** | ||
177 | * The issuer of the credential | ||
178 | */ | ||
179 | struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key; | ||
180 | |||
181 | /** | ||
182 | * Public key of the subject this credential was issued to | ||
183 | */ | ||
184 | struct GNUNET_CRYPTO_EcdsaPublicKey subject_key; | ||
185 | |||
186 | /** | ||
187 | * Signature of this credential | ||
188 | */ | ||
189 | struct GNUNET_CRYPTO_EcdsaSignature signature; | ||
190 | |||
191 | /** | ||
192 | * Expiration of this credential | ||
193 | */ | ||
194 | struct GNUNET_TIME_Absolute expiration; | ||
195 | |||
196 | /** | ||
197 | * Length of the attribute | ||
198 | */ | ||
199 | uint32_t issuer_attribute_len; | ||
200 | |||
201 | /** | ||
202 | * The attribute | ||
203 | */ | ||
204 | const char *issuer_attribute; | ||
205 | |||
206 | }; | ||
207 | |||
56 | 208 | ||
57 | 209 | ||
58 | /** | 210 | /** |
@@ -61,7 +213,7 @@ struct GNUNET_CREDENTIAL_LookupRequest; | |||
61 | * @param cfg configuration to use | 213 | * @param cfg configuration to use |
62 | * @return handle to the Credential service, or NULL on error | 214 | * @return handle to the Credential service, or NULL on error |
63 | */ | 215 | */ |
64 | struct GNUNET_Credential_Handle * | 216 | struct GNUNET_CREDENTIAL_Handle * |
65 | GNUNET_CREDENTIAL_connect (const struct GNUNET_CONFIGURATION_Handle *cfg); | 217 | GNUNET_CREDENTIAL_connect (const struct GNUNET_CONFIGURATION_Handle *cfg); |
66 | 218 | ||
67 | 219 | ||
@@ -75,56 +227,129 @@ GNUNET_CREDENTIAL_disconnect (struct GNUNET_CREDENTIAL_Handle *handle); | |||
75 | 227 | ||
76 | 228 | ||
77 | /** | 229 | /** |
78 | * Iterator called on obtained result for a Credential lookup. | 230 | * Iterator called on obtained result for an attribute verification. |
79 | * | 231 | * |
80 | * @param cls closure | 232 | * @param cls closure |
81 | * @param issuer the issuer chain | 233 | * @param d_count the number of delegations processed |
82 | * @param issuer_len length of issuer chain | 234 | * @param delegation_chain the delegations processed |
83 | * @param value the value returned | 235 | * @param c_count the number of credentials found |
236 | * @param credential the credentials | ||
84 | */ | 237 | */ |
85 | typedef void | 238 | typedef void (*GNUNET_CREDENTIAL_CredentialResultProcessor) (void *cls, |
86 | (*GNUNET_CREDENTIAL_LookupResultProcessor) (void *cls, | 239 | unsigned int d_count, |
87 | struct GNUNET_IDENTITY_Ego *issuer, | 240 | struct GNUNET_CREDENTIAL_Delegation *delegation_chain, |
88 | uint16_t issuer_len, | 241 | unsigned int c_count, |
89 | const struct GNUNET_CREDENTIAL_Value *value); | 242 | struct GNUNET_CREDENTIAL_Credential *credential); |
90 | 243 | ||
244 | /** | ||
245 | * Iterator called on obtained result for an attribute delegation. | ||
246 | * | ||
247 | * @param cls closure | ||
248 | * @param success GNUNET_YES if successful | ||
249 | * @param result the record data that can be handed to the subject | ||
250 | */ | ||
251 | typedef void (*GNUNET_CREDENTIAL_DelegateResultProcessor) (void *cls, | ||
252 | uint32_t success); | ||
91 | 253 | ||
92 | /** | 254 | /** |
93 | * Perform an asynchronous lookup operation for a credential. | 255 | * Iterator called on obtained result for an attribute delegation removal. |
256 | * | ||
257 | * @param cls closure | ||
258 | * @param success GNUNET_YES if successful | ||
259 | * @param result the record data that can be handed to the subject | ||
260 | */ | ||
261 | typedef void (*GNUNET_CREDENTIAL_RemoveDelegateResultProcessor) (void *cls, | ||
262 | uint32_t success); | ||
263 | |||
264 | |||
265 | /** | ||
266 | * Performs attribute verification. | ||
267 | * Checks if there is a delegation chain from | ||
268 | * attribute ``issuer_attribute'' issued by the issuer | ||
269 | * with public key ``issuer_key'' maps to the attribute | ||
270 | * ``subject_attribute'' claimed by the subject with key | ||
271 | * ``subject_key'' | ||
94 | * | 272 | * |
95 | * @param handle handle to the Credential service | 273 | * @param handle handle to the Credential service |
96 | * @param credential the credential to look up | 274 | * @param issuer_key the issuer public key |
97 | * @param subject Ego to check the credential for | 275 | * @param issuer_attribute the issuer attribute |
276 | * @param subject_key the subject public key | ||
277 | * @param subject_attribute the attribute claimed by the subject | ||
98 | * @param proc function to call on result | 278 | * @param proc function to call on result |
99 | * @param proc_cls closure for processor | 279 | * @param proc_cls closure for processor |
100 | * @return handle to the queued request | 280 | * @return handle to the queued request |
101 | */ | 281 | */ |
102 | struct GNUNET_CREDENTIAL_LookupRequest * | 282 | struct GNUNET_CREDENTIAL_Request* |
103 | GNUNET_CREDENTIAL_lookup (struct GNUNET_CREDENTIAL_Handle *handle, | 283 | GNUNET_CREDENTIAL_verify (struct GNUNET_CREDENTIAL_Handle *handle, |
104 | const char *credential, | 284 | const struct GNUNET_CRYPTO_EcdsaPublicKey *issuer_key, |
105 | const struct GNUNET_IDENTITY_Ego *subject, | 285 | const char *issuer_attribute, |
106 | GNUNET_CREDENTIAL_LookupResultProcessor proc, | 286 | const struct GNUNET_CRYPTO_EcdsaPublicKey *subject_key, |
287 | uint32_t credential_count, | ||
288 | const struct GNUNET_CREDENTIAL_Credential *credentials, | ||
289 | GNUNET_CREDENTIAL_CredentialResultProcessor proc, | ||
107 | void *proc_cls); | 290 | void *proc_cls); |
108 | 291 | ||
292 | struct GNUNET_CREDENTIAL_Request* | ||
293 | GNUNET_CREDENTIAL_collect (struct GNUNET_CREDENTIAL_Handle *handle, | ||
294 | const struct GNUNET_CRYPTO_EcdsaPublicKey *issuer_key, | ||
295 | const char *issuer_attribute, | ||
296 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *subject_key, | ||
297 | GNUNET_CREDENTIAL_CredentialResultProcessor proc, | ||
298 | void *proc_cls); | ||
109 | 299 | ||
110 | /** | 300 | /** |
111 | * Issue a credential to an identity | 301 | * Delegate an attribute |
112 | * | 302 | * |
113 | * @param handle handle to the Credential service | 303 | * @param handle handle to the Credential service |
114 | * @param issuer the identity that issues the credential | 304 | * @param issuer the ego that should be used to delegate the attribute |
115 | * @param subject the subject of the credential | 305 | * @param attribute the name of the attribute to delegate |
116 | * @param credential the name of the credential | 306 | * @param subject the subject of the delegation |
117 | * @param value the value of the credential | 307 | * @param delegated_attribute the name of the attribute that is delegated to |
308 | * @return handle to the queued request | ||
309 | */ | ||
310 | struct GNUNET_CREDENTIAL_Request * | ||
311 | GNUNET_CREDENTIAL_add_delegation (struct GNUNET_CREDENTIAL_Handle *handle, | ||
312 | struct GNUNET_IDENTITY_Ego *issuer, | ||
313 | const char *attribute, | ||
314 | struct GNUNET_CRYPTO_EcdsaPublicKey *subject, | ||
315 | const char *delegated_attribute, | ||
316 | GNUNET_CREDENTIAL_DelegateResultProcessor proc, | ||
317 | void *proc_cls); | ||
318 | |||
319 | /** | ||
320 | * Remove a delegation | ||
321 | * | ||
322 | * @param handle handle to the Credential service | ||
323 | * @param issuer the ego that was used to delegate the attribute | ||
324 | * @param attribute the name of the attribute that is delegated | ||
118 | * @return handle to the queued request | 325 | * @return handle to the queued request |
119 | */ | 326 | */ |
120 | struct GNUNET_CREDENTIAL_IssueRequest * | 327 | struct GNUNET_CREDENTIAL_Request * |
121 | GNUNET_CREDENTIAL_issue (struct GNUNET_CREDENTIAL_Handle *handle, | 328 | GNUNET_CREDENTIAL_remove_delegation (struct GNUNET_CREDENTIAL_Handle *handle, |
122 | struct GNUNET_IDENTITY_Ego *issuer, | 329 | struct GNUNET_IDENTITY_Ego *issuer, |
123 | struct GNUNET_IDENTITY_Ego *subject, | 330 | const char *attribute, |
124 | const char *credential, | 331 | GNUNET_CREDENTIAL_RemoveDelegateResultProcessor proc, |
125 | struct GNUNET_CREDENTIAL_Value *value, | 332 | void *proc_cls); |
126 | GNUNET_CREDENTIAL_IssueResultProcessor proc, | 333 | |
127 | void *proc_cls); | 334 | |
335 | |||
336 | /** | ||
337 | * Issue an attribute to a subject | ||
338 | * | ||
339 | * @param handle handle to the Credential service | ||
340 | * @param issuer the ego that should be used to issue the attribute | ||
341 | * @param subject the subject of the attribute | ||
342 | * @param attribute the name of the attribute | ||
343 | * @param expiration the TTL of the credential | ||
344 | * @return handle to the queued request | ||
345 | */ | ||
346 | struct GNUNET_CREDENTIAL_Credential* | ||
347 | GNUNET_CREDENTIAL_credential_issue ( | ||
348 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *issuer, | ||
349 | struct GNUNET_CRYPTO_EcdsaPublicKey *subject, | ||
350 | const char *attribute, | ||
351 | struct GNUNET_TIME_Absolute *expiration); | ||
352 | |||
128 | 353 | ||
129 | /** | 354 | /** |
130 | * Remove a credential | 355 | * Remove a credential |
@@ -135,14 +360,15 @@ GNUNET_CREDENTIAL_issue (struct GNUNET_CREDENTIAL_Handle *handle, | |||
135 | * @param credential the name of the credential | 360 | * @param credential the name of the credential |
136 | * @return handle to the queued request | 361 | * @return handle to the queued request |
137 | */ | 362 | */ |
138 | struct GNUNET_CREDENTIAL_IssueRequest * | 363 | /** |
139 | GNUNET_CREDENTIAL_remove (struct GNUNET_CREDENTIAL_Handle *handle, | 364 | struct GNUNET_CREDENTIAL_IssueRequest * |
140 | struct GNUNET_IDENTITY_Ego *issuer, | 365 | GNUNET_CREDENTIAL_remove (struct GNUNET_CREDENTIAL_Handle *handle, |
141 | struct GNUNET_IDENTITY_Ego *subject, | 366 | struct GNUNET_IDENTITY_Ego *issuer, |
142 | const char *credential, | 367 | struct GNUNET_IDENTITY_Ego *subject, |
143 | GNUNET_CREDENTIAL_IssueResultProcessor proc, | 368 | const char *credential, |
144 | void *proc_cls); | 369 | GNUNET_CREDENTIAL_IssueResultProcessor proc, |
145 | 370 | void *proc_cls); | |
371 | */ | ||
146 | 372 | ||
147 | 373 | ||
148 | /** | 374 | /** |
@@ -151,7 +377,7 @@ GNUNET_CREDENTIAL_remove (struct GNUNET_CREDENTIAL_Handle *handle, | |||
151 | * @param lr the lookup request to cancel | 377 | * @param lr the lookup request to cancel |
152 | */ | 378 | */ |
153 | void | 379 | void |
154 | GNUNET_CREDENTIAL_lookup_cancel (struct GNUNET_CREDENTIAL_LookupRequest *lr); | 380 | GNUNET_CREDENTIAL_request_cancel (struct GNUNET_CREDENTIAL_Request *vr); |
155 | 381 | ||
156 | 382 | ||
157 | #if 0 /* keep Emacsens' auto-indent happy */ | 383 | #if 0 /* keep Emacsens' auto-indent happy */ |
diff --git a/src/include/gnunet_crypto_lib.h b/src/include/gnunet_crypto_lib.h index e886a561c..2fd67ae1b 100644 --- a/src/include/gnunet_crypto_lib.h +++ b/src/include/gnunet_crypto_lib.h | |||
@@ -395,6 +395,11 @@ struct GNUNET_CRYPTO_PaillierCiphertext | |||
395 | unsigned char bits[GNUNET_CRYPTO_PAILLIER_BITS * 2 / 8]; | 395 | unsigned char bits[GNUNET_CRYPTO_PAILLIER_BITS * 2 / 8]; |
396 | }; | 396 | }; |
397 | 397 | ||
398 | /** | ||
399 | * @brief type for ABE master keys | ||
400 | */ | ||
401 | struct GNUNET_CRYPTO_AbeMasterKey; | ||
402 | |||
398 | 403 | ||
399 | /* **************** Functions and Macros ************* */ | 404 | /* **************** Functions and Macros ************* */ |
400 | 405 | ||
@@ -2137,6 +2142,83 @@ GNUNET_CRYPTO_rsa_verify (const struct GNUNET_HashCode *hash, | |||
2137 | const struct GNUNET_CRYPTO_RsaPublicKey *public_key); | 2142 | const struct GNUNET_CRYPTO_RsaPublicKey *public_key); |
2138 | 2143 | ||
2139 | 2144 | ||
2145 | /** | ||
2146 | * @ingroup crypto | ||
2147 | * Create a new CP-ABE master key. Caller must free return value. | ||
2148 | * | ||
2149 | * @return fresh private key; free using #GNUNET_free | ||
2150 | */ | ||
2151 | struct GNUNET_CRYPTO_AbeMasterKey * | ||
2152 | GNUNET_CRYPTO_cpabe_create_master_key (void); | ||
2153 | void | ||
2154 | GNUNET_CRYPTO_cpabe_delete_master_key (struct GNUNET_CRYPTO_AbeMasterKey *key); | ||
2155 | |||
2156 | /** | ||
2157 | * @ingroup crypto | ||
2158 | * Create a new CP-ABE key. Caller must free return value. | ||
2159 | * | ||
2160 | * @return fresh private key; free using #GNUNET_free | ||
2161 | */ | ||
2162 | struct GNUNET_CRYPTO_AbeKey * | ||
2163 | GNUNET_CRYPTO_cpabe_create_key (struct GNUNET_CRYPTO_AbeMasterKey *msk, | ||
2164 | char **attrs); | ||
2165 | void | ||
2166 | GNUNET_CRYPTO_cpabe_delete_key (struct GNUNET_CRYPTO_AbeKey *key, | ||
2167 | int delete_pub); | ||
2168 | |||
2169 | |||
2170 | /** | ||
2171 | * @ingroup crypto | ||
2172 | * Encrypt a block using sessionkey. | ||
2173 | * | ||
2174 | * @param block the block to encrypt | ||
2175 | * @param size the size of the @a block | ||
2176 | * @param sessionkey the key used to encrypt | ||
2177 | * @param iv the initialization vector to use, use INITVALUE | ||
2178 | * for streams. | ||
2179 | * @return the size of the encrypted block, -1 for errors | ||
2180 | */ | ||
2181 | ssize_t | ||
2182 | GNUNET_CRYPTO_cpabe_encrypt (const void *block, | ||
2183 | size_t size, | ||
2184 | const char *policy, | ||
2185 | const struct GNUNET_CRYPTO_AbeMasterKey *key, | ||
2186 | void **result); | ||
2187 | |||
2188 | /** | ||
2189 | * @ingroup crypto | ||
2190 | * Encrypt a block using sessionkey. | ||
2191 | * | ||
2192 | * @param block the block to encrypt | ||
2193 | * @param size the size of the @a block | ||
2194 | * @param sessionkey the key used to encrypt | ||
2195 | * @param iv the initialization vector to use, use INITVALUE | ||
2196 | * for streams. | ||
2197 | * @return the size of the encrypted block, -1 for errors | ||
2198 | */ | ||
2199 | ssize_t | ||
2200 | GNUNET_CRYPTO_cpabe_decrypt (const void *block, | ||
2201 | size_t size, | ||
2202 | const struct GNUNET_CRYPTO_AbeKey *key, | ||
2203 | void **result); | ||
2204 | |||
2205 | ssize_t | ||
2206 | GNUNET_CRYPTO_cpabe_serialize_key (const struct GNUNET_CRYPTO_AbeKey *key, | ||
2207 | void **result); | ||
2208 | |||
2209 | struct GNUNET_CRYPTO_AbeKey* | ||
2210 | GNUNET_CRYPTO_cpabe_deserialize_key (const void *data, | ||
2211 | size_t len); | ||
2212 | |||
2213 | ssize_t | ||
2214 | GNUNET_CRYPTO_cpabe_serialize_master_key (const struct GNUNET_CRYPTO_AbeMasterKey *key, | ||
2215 | void **result); | ||
2216 | |||
2217 | struct GNUNET_CRYPTO_AbeMasterKey* | ||
2218 | GNUNET_CRYPTO_cpabe_deserialize_master_key (const void *data, | ||
2219 | size_t len); | ||
2220 | |||
2221 | |||
2140 | #if 0 /* keep Emacsens' auto-indent happy */ | 2222 | #if 0 /* keep Emacsens' auto-indent happy */ |
2141 | { | 2223 | { |
2142 | #endif | 2224 | #endif |
diff --git a/src/include/gnunet_gnsrecord_lib.h b/src/include/gnunet_gnsrecord_lib.h index 985ae1f7a..d03b4db3b 100644 --- a/src/include/gnunet_gnsrecord_lib.h +++ b/src/include/gnunet_gnsrecord_lib.h | |||
@@ -109,9 +109,29 @@ extern "C" | |||
109 | #define GNUNET_GNSRECORD_TYPE_ID_TOKEN_METADATA 65546 | 109 | #define GNUNET_GNSRECORD_TYPE_ID_TOKEN_METADATA 65546 |
110 | 110 | ||
111 | /** | 111 | /** |
112 | * Record type for credential | ||
113 | */ | ||
114 | #define GNUNET_GNSRECORD_TYPE_CREDENTIAL 65547 | ||
115 | |||
116 | /** | ||
117 | * Record type for policies | ||
118 | */ | ||
119 | #define GNUNET_GNSRECORD_TYPE_POLICY 65548 | ||
120 | |||
121 | /** | ||
112 | * Record type for reverse lookups | 122 | * Record type for reverse lookups |
113 | */ | 123 | */ |
114 | #define GNUNET_GNSRECORD_TYPE_REVERSE 65548 | 124 | #define GNUNET_GNSRECORD_TYPE_ATTRIBUTE 65549 |
125 | |||
126 | /** | ||
127 | * Record type for ABE records | ||
128 | */ | ||
129 | #define GNUNET_GNSRECORD_TYPE_ABE_KEY 65550 | ||
130 | |||
131 | /** | ||
132 | * Record type for ABE master keys | ||
133 | */ | ||
134 | #define GNUNET_GNSRECORD_TYPE_ABE_MASTER 65551 | ||
115 | 135 | ||
116 | /** | 136 | /** |
117 | * Flags that can be set for a record. | 137 | * Flags that can be set for a record. |
diff --git a/src/include/gnunet_identity_attribute_lib.h b/src/include/gnunet_identity_attribute_lib.h new file mode 100644 index 000000000..a6c9e1f1c --- /dev/null +++ b/src/include/gnunet_identity_attribute_lib.h | |||
@@ -0,0 +1,277 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet. | ||
3 | Copyright (C) 2017 GNUnet e.V. | ||
4 | |||
5 | GNUnet is free software; you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License as published | ||
7 | by the Free Software Foundation; either version 3, or (at your | ||
8 | option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with GNUnet; see the file COPYING. If not, write to the | ||
17 | Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, | ||
18 | Boston, MA 02110-1301, USA. | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @author Martin Schanzenbach | ||
23 | * | ||
24 | * @file | ||
25 | * Identity attribute definitions | ||
26 | * | ||
27 | * @defgroup identity-provider Identity Provider service | ||
28 | * @{ | ||
29 | */ | ||
30 | #ifndef GNUNET_IDENTITY_ATTRIBUTE_LIB_H | ||
31 | #define GNUNET_IDENTITY_ATTRIBUTE_LIB_H | ||
32 | |||
33 | #ifdef __cplusplus | ||
34 | extern "C" | ||
35 | { | ||
36 | #if 0 /* keep Emacsens' auto-indent happy */ | ||
37 | } | ||
38 | #endif | ||
39 | #endif | ||
40 | |||
41 | #include "gnunet_util_lib.h" | ||
42 | |||
43 | |||
44 | /** | ||
45 | * No value attribute. | ||
46 | */ | ||
47 | #define GNUNET_IDENTITY_ATTRIBUTE_TYPE_NONE 0 | ||
48 | |||
49 | /** | ||
50 | * String attribute. | ||
51 | */ | ||
52 | #define GNUNET_IDENTITY_ATTRIBUTE_TYPE_STRING 1 | ||
53 | |||
54 | |||
55 | |||
56 | /** | ||
57 | * An attribute. | ||
58 | */ | ||
59 | struct GNUNET_IDENTITY_ATTRIBUTE_Claim | ||
60 | { | ||
61 | /** | ||
62 | * The name of the attribute. Note "name" must never be individually | ||
63 | * free'd | ||
64 | */ | ||
65 | const char* name; | ||
66 | |||
67 | /** | ||
68 | * Type of Claim | ||
69 | */ | ||
70 | uint32_t type; | ||
71 | |||
72 | /** | ||
73 | * Version | ||
74 | */ | ||
75 | uint32_t version; | ||
76 | |||
77 | /** | ||
78 | * Number of bytes in @e data. | ||
79 | */ | ||
80 | size_t data_size; | ||
81 | |||
82 | /** | ||
83 | * Binary value stored as attribute value. Note: "data" must never | ||
84 | * be individually 'malloc'ed, but instead always points into some | ||
85 | * existing data area. | ||
86 | */ | ||
87 | const void *data; | ||
88 | |||
89 | }; | ||
90 | |||
91 | struct GNUNET_IDENTITY_ATTRIBUTE_ClaimList | ||
92 | { | ||
93 | /** | ||
94 | * List head | ||
95 | */ | ||
96 | struct GNUNET_IDENTITY_ATTRIBUTE_ClaimListEntry *list_head; | ||
97 | |||
98 | /** | ||
99 | * List tail | ||
100 | */ | ||
101 | struct GNUNET_IDENTITY_ATTRIBUTE_ClaimListEntry *list_tail; | ||
102 | }; | ||
103 | |||
104 | struct GNUNET_IDENTITY_ATTRIBUTE_ClaimListEntry | ||
105 | { | ||
106 | /** | ||
107 | * DLL | ||
108 | */ | ||
109 | struct GNUNET_IDENTITY_ATTRIBUTE_ClaimListEntry *prev; | ||
110 | |||
111 | /** | ||
112 | * DLL | ||
113 | */ | ||
114 | struct GNUNET_IDENTITY_ATTRIBUTE_ClaimListEntry *next; | ||
115 | |||
116 | /** | ||
117 | * The attribute claim | ||
118 | */ | ||
119 | struct GNUNET_IDENTITY_ATTRIBUTE_Claim *claim; | ||
120 | }; | ||
121 | |||
122 | /** | ||
123 | * Create a new attribute claim. | ||
124 | * | ||
125 | * @param name the attribute name | ||
126 | * @param type the attribute type | ||
127 | * @param data the attribute value | ||
128 | * @param data_size the attribute value size | ||
129 | * @return the new attribute | ||
130 | */ | ||
131 | struct GNUNET_IDENTITY_ATTRIBUTE_Claim * | ||
132 | GNUNET_IDENTITY_ATTRIBUTE_claim_new (const char* attr_name, | ||
133 | uint32_t type, | ||
134 | const void* data, | ||
135 | size_t data_size); | ||
136 | |||
137 | |||
138 | /** | ||
139 | * Get required size for serialization buffer | ||
140 | * | ||
141 | * @param attrs the attribute list to serialize | ||
142 | * | ||
143 | * @return the required buffer size | ||
144 | */ | ||
145 | size_t | ||
146 | GNUNET_IDENTITY_ATTRIBUTE_list_serialize_get_size (const struct GNUNET_IDENTITY_ATTRIBUTE_ClaimList *attrs); | ||
147 | |||
148 | void | ||
149 | GNUNET_IDENTITY_ATTRIBUTE_list_destroy (struct GNUNET_IDENTITY_ATTRIBUTE_ClaimList *attrs); | ||
150 | |||
151 | |||
152 | /** | ||
153 | * Serialize an attribute list | ||
154 | * | ||
155 | * @param attrs the attribute list to serialize | ||
156 | * @param result the serialized attribute | ||
157 | * | ||
158 | * @return length of serialized data | ||
159 | */ | ||
160 | size_t | ||
161 | GNUNET_IDENTITY_ATTRIBUTE_list_serialize (const struct GNUNET_IDENTITY_ATTRIBUTE_ClaimList *attrs, | ||
162 | char *result); | ||
163 | |||
164 | /** | ||
165 | * Deserialize an attribute list | ||
166 | * | ||
167 | * @param data the serialized attribute list | ||
168 | * @param data_size the length of the serialized data | ||
169 | * | ||
170 | * @return a GNUNET_IDENTITY_PROVIDER_AttributeList, must be free'd by caller | ||
171 | */ | ||
172 | struct GNUNET_IDENTITY_ATTRIBUTE_ClaimList * | ||
173 | GNUNET_IDENTITY_ATTRIBUTE_list_deserialize (const char* data, | ||
174 | size_t data_size); | ||
175 | |||
176 | |||
177 | /** | ||
178 | * Get required size for serialization buffer | ||
179 | * | ||
180 | * @param attr the attribute to serialize | ||
181 | * | ||
182 | * @return the required buffer size | ||
183 | */ | ||
184 | size_t | ||
185 | GNUNET_IDENTITY_ATTRIBUTE_serialize_get_size (const struct GNUNET_IDENTITY_ATTRIBUTE_Claim *attr); | ||
186 | |||
187 | |||
188 | |||
189 | /** | ||
190 | * Serialize an attribute | ||
191 | * | ||
192 | * @param attr the attribute to serialize | ||
193 | * @param result the serialized attribute | ||
194 | * | ||
195 | * @return length of serialized data | ||
196 | */ | ||
197 | size_t | ||
198 | GNUNET_IDENTITY_ATTRIBUTE_serialize (const struct GNUNET_IDENTITY_ATTRIBUTE_Claim *attr, | ||
199 | char *result); | ||
200 | |||
201 | /** | ||
202 | * Deserialize an attribute | ||
203 | * | ||
204 | * @param data the serialized attribute | ||
205 | * @param data_size the length of the serialized data | ||
206 | * | ||
207 | * @return a GNUNET_IDENTITY_PROVIDER_Attribute, must be free'd by caller | ||
208 | */ | ||
209 | struct GNUNET_IDENTITY_ATTRIBUTE_Claim * | ||
210 | GNUNET_IDENTITY_ATTRIBUTE_deserialize (const char* data, | ||
211 | size_t data_size); | ||
212 | |||
213 | struct GNUNET_IDENTITY_ATTRIBUTE_ClaimList* | ||
214 | GNUNET_IDENTITY_ATTRIBUTE_list_dup (const struct GNUNET_IDENTITY_ATTRIBUTE_ClaimList *attrs); | ||
215 | |||
216 | /** | ||
217 | * Convert a type name to the corresponding number | ||
218 | * | ||
219 | * @param typename name to convert | ||
220 | * @return corresponding number, UINT32_MAX on error | ||
221 | */ | ||
222 | uint32_t | ||
223 | GNUNET_IDENTITY_ATTRIBUTE_typename_to_number (const char *typename); | ||
224 | |||
225 | /** | ||
226 | * Convert human-readable version of a 'claim' of an attribute to the binary | ||
227 | * representation | ||
228 | * | ||
229 | * @param type type of the claim | ||
230 | * @param s human-readable string | ||
231 | * @param data set to value in binary encoding (will be allocated) | ||
232 | * @param data_size set to number of bytes in @a data | ||
233 | * @return #GNUNET_OK on success | ||
234 | */ | ||
235 | int | ||
236 | GNUNET_IDENTITY_ATTRIBUTE_string_to_value (uint32_t type, | ||
237 | const char *s, | ||
238 | void **data, | ||
239 | size_t *data_size); | ||
240 | |||
241 | /** | ||
242 | * Convert the 'claim' of an attribute to a string | ||
243 | * | ||
244 | * @param type the type of attribute | ||
245 | * @param data claim in binary encoding | ||
246 | * @param data_size number of bytes in @a data | ||
247 | * @return NULL on error, otherwise human-readable representation of the claim | ||
248 | */ | ||
249 | char * | ||
250 | GNUNET_IDENTITY_ATTRIBUTE_value_to_string (uint32_t type, | ||
251 | const void* data, | ||
252 | size_t data_size); | ||
253 | |||
254 | /** | ||
255 | * Convert a type number to the corresponding type string | ||
256 | * | ||
257 | * @param type number of a type | ||
258 | * @return corresponding typestring, NULL on error | ||
259 | */ | ||
260 | const char* | ||
261 | GNUNET_IDENTITY_ATTRIBUTE_number_to_typename (uint32_t type); | ||
262 | |||
263 | |||
264 | #if 0 /* keep Emacsens' auto-indent happy */ | ||
265 | { | ||
266 | #endif | ||
267 | #ifdef __cplusplus | ||
268 | } | ||
269 | #endif | ||
270 | |||
271 | |||
272 | /* ifndef GNUNET_IDENTITY_ATTRIBUTE_LIB_H */ | ||
273 | #endif | ||
274 | |||
275 | /** @} */ /* end of group identity */ | ||
276 | |||
277 | /* end of gnunet_identity_attribute_lib.h */ | ||
diff --git a/src/include/gnunet_identity_attribute_plugin.h b/src/include/gnunet_identity_attribute_plugin.h new file mode 100644 index 000000000..edeed57fd --- /dev/null +++ b/src/include/gnunet_identity_attribute_plugin.h | |||
@@ -0,0 +1,149 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet | ||
3 | Copyright (C) 2012, 2013 GNUnet e.V. | ||
4 | |||
5 | GNUnet is free software; you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License as published | ||
7 | by the Free Software Foundation; either version 3, or (at your | ||
8 | option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with GNUnet; see the file COPYING. If not, write to the | ||
17 | Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, | ||
18 | Boston, MA 02110-1301, USA. | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @author Martin Schanzenbach | ||
23 | * | ||
24 | * @file | ||
25 | * Plugin API for the idp database backend | ||
26 | * | ||
27 | * @defgroup identity-provider-plugin IdP service plugin API | ||
28 | * Plugin API for the idp database backend | ||
29 | * @{ | ||
30 | */ | ||
31 | #ifndef GNUNET_IDENTITY_ATTRIBUTE_PLUGIN_H | ||
32 | #define GNUNET_IDENTITY_ATTRIBUTE_PLUGIN_H | ||
33 | |||
34 | #include "gnunet_util_lib.h" | ||
35 | #include "gnunet_identity_attribute_lib.h" | ||
36 | |||
37 | #ifdef __cplusplus | ||
38 | extern "C" | ||
39 | { | ||
40 | #if 0 /* keep Emacsens' auto-indent happy */ | ||
41 | } | ||
42 | #endif | ||
43 | #endif | ||
44 | |||
45 | |||
46 | /** | ||
47 | * Function called to convert the binary value @a data of an attribute of | ||
48 | * type @a type to a human-readable string. | ||
49 | * | ||
50 | * @param cls closure | ||
51 | * @param type type of the attribute | ||
52 | * @param data value in binary encoding | ||
53 | * @param data_size number of bytes in @a data | ||
54 | * @return NULL on error, otherwise human-readable representation of the value | ||
55 | */ | ||
56 | typedef char * (*GNUNET_IDENTITY_ATTRIBUTE_ValueToStringFunction) (void *cls, | ||
57 | uint32_t type, | ||
58 | const void *data, | ||
59 | size_t data_size); | ||
60 | |||
61 | |||
62 | /** | ||
63 | * Function called to convert human-readable version of the value @a s | ||
64 | * of an attribute of type @a type to the respective binary | ||
65 | * representation. | ||
66 | * | ||
67 | * @param cls closure | ||
68 | * @param type type of the attribute | ||
69 | * @param s human-readable string | ||
70 | * @param data set to value in binary encoding (will be allocated) | ||
71 | * @param data_size set to number of bytes in @a data | ||
72 | * @return #GNUNET_OK on success | ||
73 | */ | ||
74 | typedef int (*GNUNET_IDENTITY_ATTRIBUTE_StringToValueFunction) (void *cls, | ||
75 | uint32_t type, | ||
76 | const char *s, | ||
77 | void **data, | ||
78 | size_t *data_size); | ||
79 | |||
80 | |||
81 | /** | ||
82 | * Function called to convert a type name to the | ||
83 | * corresponding number. | ||
84 | * | ||
85 | * @param cls closure | ||
86 | * @param typename name to convert | ||
87 | * @return corresponding number, UINT32_MAX on error | ||
88 | */ | ||
89 | typedef uint32_t (*GNUNET_IDENTITY_ATTRIBUTE_TypenameToNumberFunction) (void *cls, | ||
90 | const char *typename); | ||
91 | |||
92 | |||
93 | /** | ||
94 | * Function called to convert a type number (i.e. 1) to the | ||
95 | * corresponding type string | ||
96 | * | ||
97 | * @param cls closure | ||
98 | * @param type number of a type to convert | ||
99 | * @return corresponding typestring, NULL on error | ||
100 | */ | ||
101 | typedef const char * (*GNUNET_IDENTITY_ATTRIBUTE_NumberToTypenameFunction) (void *cls, | ||
102 | uint32_t type); | ||
103 | |||
104 | |||
105 | /** | ||
106 | * Each plugin is required to return a pointer to a struct of this | ||
107 | * type as the return value from its entry point. | ||
108 | */ | ||
109 | struct GNUNET_IDENTITY_ATTRIBUTE_PluginFunctions | ||
110 | { | ||
111 | |||
112 | /** | ||
113 | * Closure for all of the callbacks. | ||
114 | */ | ||
115 | void *cls; | ||
116 | |||
117 | /** | ||
118 | * Conversion to string. | ||
119 | */ | ||
120 | GNUNET_IDENTITY_ATTRIBUTE_ValueToStringFunction value_to_string; | ||
121 | |||
122 | /** | ||
123 | * Conversion to binary. | ||
124 | */ | ||
125 | GNUNET_IDENTITY_ATTRIBUTE_StringToValueFunction string_to_value; | ||
126 | |||
127 | /** | ||
128 | * Typename to number. | ||
129 | */ | ||
130 | GNUNET_IDENTITY_ATTRIBUTE_TypenameToNumberFunction typename_to_number; | ||
131 | |||
132 | /** | ||
133 | * Number to typename. | ||
134 | */ | ||
135 | GNUNET_IDENTITY_ATTRIBUTE_NumberToTypenameFunction number_to_typename; | ||
136 | |||
137 | }; | ||
138 | |||
139 | |||
140 | #if 0 /* keep Emacsens' auto-indent happy */ | ||
141 | { | ||
142 | #endif | ||
143 | #ifdef __cplusplus | ||
144 | } | ||
145 | #endif | ||
146 | |||
147 | #endif | ||
148 | |||
149 | /** @} */ /* end of group */ | ||
diff --git a/src/include/gnunet_identity_provider_plugin.h b/src/include/gnunet_identity_provider_plugin.h new file mode 100644 index 000000000..4b5098d58 --- /dev/null +++ b/src/include/gnunet_identity_provider_plugin.h | |||
@@ -0,0 +1,123 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet | ||
3 | Copyright (C) 2012, 2013 GNUnet e.V. | ||
4 | |||
5 | GNUnet is free software; you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License as published | ||
7 | by the Free Software Foundation; either version 3, or (at your | ||
8 | option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with GNUnet; see the file COPYING. If not, write to the | ||
17 | Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, | ||
18 | Boston, MA 02110-1301, USA. | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @author Martin Schanzenbach | ||
23 | * | ||
24 | * @file | ||
25 | * Plugin API for the idp database backend | ||
26 | * | ||
27 | * @defgroup identity-provider-plugin IdP service plugin API | ||
28 | * Plugin API for the idp database backend | ||
29 | * @{ | ||
30 | */ | ||
31 | #ifndef GNUNET_IDENTITY_PROVIDER_PLUGIN_H | ||
32 | #define GNUNET_IDENTITY_PROVIDER_PLUGIN_H | ||
33 | |||
34 | #include "gnunet_util_lib.h" | ||
35 | #include "gnunet_identity_provider_service.h" | ||
36 | |||
37 | #ifdef __cplusplus | ||
38 | extern "C" | ||
39 | { | ||
40 | #if 0 /* keep Emacsens' auto-indent happy */ | ||
41 | } | ||
42 | #endif | ||
43 | #endif | ||
44 | |||
45 | |||
46 | /** | ||
47 | * Function called by for each matching ticket. | ||
48 | * | ||
49 | * @param cls closure | ||
50 | * @param ticket the ticket | ||
51 | */ | ||
52 | typedef void (*GNUNET_IDENTITY_PROVIDER_TicketIterator) (void *cls, | ||
53 | const struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket, | ||
54 | const struct GNUNET_IDENTITY_ATTRIBUTE_ClaimList *attrs); | ||
55 | |||
56 | |||
57 | /** | ||
58 | * @brief struct returned by the initialization function of the plugin | ||
59 | */ | ||
60 | struct GNUNET_IDENTITY_PROVIDER_PluginFunctions | ||
61 | { | ||
62 | |||
63 | /** | ||
64 | * Closure to pass to all plugin functions. | ||
65 | */ | ||
66 | void *cls; | ||
67 | |||
68 | /** | ||
69 | * Store a ticket in the database. | ||
70 | * | ||
71 | * @param cls closure (internal context for the plugin) | ||
72 | * @param ticket the ticket to store | ||
73 | * @return #GNUNET_OK on success, else #GNUNET_SYSERR | ||
74 | */ | ||
75 | int (*store_ticket) (void *cls, | ||
76 | const struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket, | ||
77 | const struct GNUNET_IDENTITY_ATTRIBUTE_ClaimList *attrs); | ||
78 | |||
79 | /** | ||
80 | * Delete a ticket from the database. | ||
81 | * | ||
82 | * @param cls closure (internal context for the plugin) | ||
83 | * @param ticket the ticket to store | ||
84 | * @return #GNUNET_OK on success, else #GNUNET_SYSERR | ||
85 | */ | ||
86 | int (*delete_ticket) (void *cls, | ||
87 | const struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket); | ||
88 | |||
89 | |||
90 | |||
91 | /** | ||
92 | * Iterate over all tickets | ||
93 | * | ||
94 | * @param cls closure (internal context for the plugin) | ||
95 | * @param identity the identity | ||
96 | * @param audience GNUNET_YES if the identity is the audience of the ticket | ||
97 | * else it is considered the issuer | ||
98 | * @param iter function to call with the result | ||
99 | * @param iter_cls closure for @a iter | ||
100 | * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error | ||
101 | */ | ||
102 | int (*iterate_tickets) (void *cls, | ||
103 | const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, | ||
104 | int audience, | ||
105 | uint64_t offset, | ||
106 | GNUNET_IDENTITY_PROVIDER_TicketIterator iter, void *iter_cls); | ||
107 | |||
108 | int (*get_ticket_attributes) (void* cls, | ||
109 | const struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket, | ||
110 | GNUNET_IDENTITY_PROVIDER_TicketIterator iter, | ||
111 | void *iter_cls); | ||
112 | }; | ||
113 | |||
114 | #if 0 /* keep Emacsens' auto-indent happy */ | ||
115 | { | ||
116 | #endif | ||
117 | #ifdef __cplusplus | ||
118 | } | ||
119 | #endif | ||
120 | |||
121 | #endif | ||
122 | |||
123 | /** @} */ /* end of group */ | ||
diff --git a/src/include/gnunet_identity_provider_service.h b/src/include/gnunet_identity_provider_service.h index e533f6f8c..6bc05d0f4 100644 --- a/src/include/gnunet_identity_provider_service.h +++ b/src/include/gnunet_identity_provider_service.h | |||
@@ -39,7 +39,7 @@ extern "C" | |||
39 | #endif | 39 | #endif |
40 | 40 | ||
41 | #include "gnunet_util_lib.h" | 41 | #include "gnunet_util_lib.h" |
42 | 42 | #include "gnunet_identity_attribute_lib.h" | |
43 | 43 | ||
44 | /** | 44 | /** |
45 | * Version number of GNUnet Identity Provider API. | 45 | * Version number of GNUnet Identity Provider API. |
@@ -57,169 +57,309 @@ struct GNUNET_IDENTITY_PROVIDER_Handle; | |||
57 | struct GNUNET_IDENTITY_PROVIDER_Token; | 57 | struct GNUNET_IDENTITY_PROVIDER_Token; |
58 | 58 | ||
59 | /** | 59 | /** |
60 | * Handle for a ticket | 60 | * The ticket |
61 | */ | 61 | */ |
62 | struct GNUNET_IDENTITY_PROVIDER_Ticket; | 62 | struct GNUNET_IDENTITY_PROVIDER_Ticket |
63 | { | ||
64 | /** | ||
65 | * The ticket issuer | ||
66 | */ | ||
67 | struct GNUNET_CRYPTO_EcdsaPublicKey identity; | ||
68 | |||
69 | /** | ||
70 | * The ticket audience | ||
71 | */ | ||
72 | struct GNUNET_CRYPTO_EcdsaPublicKey audience; | ||
73 | |||
74 | /** | ||
75 | * The ticket random (NBO) | ||
76 | */ | ||
77 | uint64_t rnd; | ||
78 | }; | ||
63 | 79 | ||
64 | /** | 80 | /** |
65 | * Handle for an operation with the identity provider service. | 81 | * Handle for an operation with the identity provider service. |
66 | */ | 82 | */ |
67 | struct GNUNET_IDENTITY_PROVIDER_Operation; | 83 | struct GNUNET_IDENTITY_PROVIDER_Operation; |
68 | 84 | ||
85 | |||
69 | /** | 86 | /** |
70 | * Method called when a token has been exchanged for a ticket. | 87 | * Connect to the identity provider service. |
71 | * On success returns a token | ||
72 | * | 88 | * |
73 | * @param cls closure | 89 | * @param cfg Configuration to contact the identity provider service. |
74 | * @param token the token | 90 | * @return handle to communicate with identity provider service |
75 | */ | 91 | */ |
76 | typedef void | 92 | struct GNUNET_IDENTITY_PROVIDER_Handle * |
77 | (*GNUNET_IDENTITY_PROVIDER_ExchangeCallback)(void *cls, | 93 | GNUNET_IDENTITY_PROVIDER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg); |
78 | const struct GNUNET_IDENTITY_PROVIDER_Token *token, | ||
79 | uint64_t ticket_nonce); | ||
80 | 94 | ||
81 | /** | 95 | /** |
82 | * Method called when a token has been issued. | 96 | * Continuation called to notify client about result of the |
83 | * On success returns a ticket that can be given to the audience to retrive the | 97 | * operation. |
84 | * token | ||
85 | * | 98 | * |
86 | * @param cls closure | 99 | * @param cls closure |
87 | * @param grant the label in GNS pointing to the token | 100 | * @param success #GNUNET_SYSERR on failure (including timeout/queue drop/failure to validate) |
88 | * @param ticket the ticket | 101 | * #GNUNET_NO if content was already there or not found |
89 | * @param token the issued token | 102 | * #GNUNET_YES (or other positive value) on success |
90 | * @param name name assigned by the user for this ego, | 103 | * @param emsg NULL on success, otherwise an error message |
91 | * NULL if the user just deleted the ego and it | ||
92 | * must thus no longer be used | ||
93 | */ | 104 | */ |
94 | typedef void | 105 | typedef void |
95 | (*GNUNET_IDENTITY_PROVIDER_IssueCallback)(void *cls, | 106 | (*GNUNET_IDENTITY_PROVIDER_ContinuationWithStatus) (void *cls, |
96 | const char *grant, | 107 | int32_t success, |
97 | const struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket, | 108 | const char *emsg); |
98 | const struct GNUNET_IDENTITY_PROVIDER_Token *token); | ||
99 | 109 | ||
100 | 110 | ||
101 | /** | 111 | /** |
102 | * Connect to the identity provider service. | 112 | * Store an attribute. If the attribute is already present, |
113 | * it is replaced with the new attribute. | ||
103 | * | 114 | * |
104 | * @param cfg Configuration to contact the identity provider service. | 115 | * @param h handle to the identity provider |
105 | * @return handle to communicate with identity provider service | 116 | * @param pkey private key of the identity |
117 | * @param attr the attribute | ||
118 | * @param cont continuation to call when done | ||
119 | * @param cont_cls closure for @a cont | ||
120 | * @return handle to abort the request | ||
106 | */ | 121 | */ |
107 | struct GNUNET_IDENTITY_PROVIDER_Handle * | 122 | struct GNUNET_IDENTITY_PROVIDER_Operation * |
108 | GNUNET_IDENTITY_PROVIDER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg); | 123 | GNUNET_IDENTITY_PROVIDER_attribute_store (struct GNUNET_IDENTITY_PROVIDER_Handle *h, |
124 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, | ||
125 | const struct GNUNET_IDENTITY_ATTRIBUTE_Claim *attr, | ||
126 | GNUNET_IDENTITY_PROVIDER_ContinuationWithStatus cont, | ||
127 | void *cont_cls); | ||
109 | 128 | ||
110 | 129 | ||
111 | /** | 130 | /** |
112 | * Issue a token for a specific audience. | 131 | * Process an attribute that was stored in the idp. |
113 | * | 132 | * |
114 | * @param id identity provider service to use | 133 | * @param cls closure |
115 | * @param iss issuer (identity) | 134 | * @param attr the attribute |
116 | * @param aud audience (identity) | ||
117 | * @param scope the identity attributes requested, comman separated | ||
118 | * @param expiration the token expiration | ||
119 | * @param nonce the nonce that will be included in token and ticket | ||
120 | * @param cb callback to call with result | ||
121 | * @param cb_cls closure | ||
122 | * @return handle to abort the operation | ||
123 | */ | 135 | */ |
124 | struct GNUNET_IDENTITY_PROVIDER_Operation * | 136 | typedef void |
125 | GNUNET_IDENTITY_PROVIDER_issue_token (struct GNUNET_IDENTITY_PROVIDER_Handle *id, | 137 | (*GNUNET_IDENTITY_PROVIDER_AttributeResult) (void *cls, |
126 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *iss_key, | 138 | const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, |
127 | const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key, | 139 | const struct GNUNET_IDENTITY_ATTRIBUTE_Claim *attr); |
128 | const char* scope, | 140 | |
129 | struct GNUNET_TIME_Absolute expiration, | ||
130 | uint64_t nonce, | ||
131 | GNUNET_IDENTITY_PROVIDER_IssueCallback cb, | ||
132 | void *cb_cls); | ||
133 | 141 | ||
134 | 142 | ||
135 | /** | 143 | /** |
136 | * Exchange a ticket for a token. Intended to be used by audience that | 144 | * List all attributes for a local identity. |
137 | * received a ticket. | 145 | * This MUST lock the `struct GNUNET_IDENTITY_PROVIDER_Handle` |
146 | * for any other calls than #GNUNET_IDENTITY_PROVIDER_get_attributes_next() and | ||
147 | * #GNUNET_IDENTITY_PROVIDER_get_attributes_stop. @a proc will be called once | ||
148 | * immediately, and then again after | ||
149 | * #GNUNET_IDENTITY_PROVIDER_get_attributes_next() is invoked. | ||
138 | * | 150 | * |
139 | * @param id identity provider service to use | 151 | * On error (disconnect), @a error_cb will be invoked. |
140 | * @param ticket the ticket to exchange | 152 | * On normal completion, @a finish_cb proc will be |
141 | * @param aud_privkey the audience of the ticket | 153 | * invoked. |
142 | * @param cont function to call once the operation finished | 154 | * |
143 | * @param cont_cls closure for @a cont | 155 | * @param h handle to the idp |
144 | * @return handle to abort the operation | 156 | * @param identity identity to access |
157 | * @param error_cb function to call on error (i.e. disconnect), | ||
158 | * the handle is afterwards invalid | ||
159 | * @param error_cb_cls closure for @a error_cb | ||
160 | * @param proc function to call on each attribute; it | ||
161 | * will be called repeatedly with a value (if available) | ||
162 | * @param proc_cls closure for @a proc | ||
163 | * @param finish_cb function to call on completion | ||
164 | * the handle is afterwards invalid | ||
165 | * @param finish_cb_cls closure for @a finish_cb | ||
166 | * @return an iterator handle to use for iteration | ||
145 | */ | 167 | */ |
146 | struct GNUNET_IDENTITY_PROVIDER_Operation * | 168 | struct GNUNET_IDENTITY_PROVIDER_AttributeIterator * |
147 | GNUNET_IDENTITY_PROVIDER_exchange_ticket (struct GNUNET_IDENTITY_PROVIDER_Handle *id, | 169 | GNUNET_IDENTITY_PROVIDER_get_attributes_start (struct GNUNET_IDENTITY_PROVIDER_Handle *h, |
148 | const struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket, | 170 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, |
149 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *aud_privkey, | 171 | GNUNET_SCHEDULER_TaskCallback error_cb, |
150 | GNUNET_IDENTITY_PROVIDER_ExchangeCallback cont, | 172 | void *error_cb_cls, |
151 | void *cont_cls); | 173 | GNUNET_IDENTITY_PROVIDER_AttributeResult proc, |
174 | void *proc_cls, | ||
175 | GNUNET_SCHEDULER_TaskCallback finish_cb, | ||
176 | void *finish_cb_cls); | ||
152 | 177 | ||
153 | 178 | ||
154 | /** | 179 | /** |
155 | * Disconnect from identity provider service. | 180 | * Calls the record processor specified in #GNUNET_IDENTITY_PROVIDER_get_attributes_start |
181 | * for the next record. | ||
156 | * | 182 | * |
157 | * @param h identity provider service to disconnect | 183 | * @param it the iterator |
158 | */ | 184 | */ |
159 | void | 185 | void |
160 | GNUNET_IDENTITY_PROVIDER_disconnect (struct GNUNET_IDENTITY_PROVIDER_Handle *h); | 186 | GNUNET_IDENTITY_PROVIDER_get_attributes_next (struct GNUNET_IDENTITY_PROVIDER_AttributeIterator *it); |
161 | 187 | ||
162 | 188 | ||
163 | /** | 189 | /** |
164 | * Cancel an identity provider operation. Note that the operation MAY still | 190 | * Stops iteration and releases the idp handle for further calls. Must |
165 | * be executed; this merely cancels the continuation; if the request | 191 | * be called on any iteration that has not yet completed prior to calling |
166 | * was already transmitted, the service may still choose to complete | 192 | * #GNUNET_IDENTITY_PROVIDER_disconnect. |
167 | * the operation. | ||
168 | * | 193 | * |
169 | * @param op operation to cancel | 194 | * @param it the iterator |
170 | */ | 195 | */ |
171 | void | 196 | void |
172 | GNUNET_IDENTITY_PROVIDER_cancel (struct GNUNET_IDENTITY_PROVIDER_Operation *op); | 197 | GNUNET_IDENTITY_PROVIDER_get_attributes_stop (struct GNUNET_IDENTITY_PROVIDER_AttributeIterator *it); |
173 | 198 | ||
174 | 199 | ||
175 | /** | 200 | /** |
176 | * Convenience API | 201 | * Method called when a token has been issued. |
202 | * On success returns a ticket that can be given to the audience to retrive the | ||
203 | * token | ||
204 | * | ||
205 | * @param cls closure | ||
206 | * @param ticket the ticket | ||
177 | */ | 207 | */ |
208 | typedef void | ||
209 | (*GNUNET_IDENTITY_PROVIDER_TicketCallback)(void *cls, | ||
210 | const struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket); | ||
178 | 211 | ||
179 | /** | 212 | /** |
180 | * Destroy token | 213 | * Issues a ticket to another identity. The identity may use |
214 | * @GNUNET_IDENTITY_PROVIDER_authorization_ticket_consume to consume the ticket | ||
215 | * and retrieve the attributes specified in the AttributeList. | ||
181 | * | 216 | * |
182 | * @param token the token | 217 | * @param id the identity provider to use |
218 | * @param iss the issuing identity | ||
219 | * @param rp the subject of the ticket (the relying party) | ||
220 | * @param attr the attributes that the relying party is given access to | ||
221 | * @param cb the callback | ||
222 | * @param cb_cls the callback closure | ||
223 | * @return handle to abort the operation | ||
183 | */ | 224 | */ |
184 | void | 225 | struct GNUNET_IDENTITY_PROVIDER_Operation * |
185 | GNUNET_IDENTITY_PROVIDER_token_destroy(struct GNUNET_IDENTITY_PROVIDER_Token *token); | 226 | GNUNET_IDENTITY_PROVIDER_ticket_issue (struct GNUNET_IDENTITY_PROVIDER_Handle *id, |
227 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *iss, | ||
228 | const struct GNUNET_CRYPTO_EcdsaPublicKey *rp, | ||
229 | const struct GNUNET_IDENTITY_ATTRIBUTE_ClaimList *attrs, | ||
230 | GNUNET_IDENTITY_PROVIDER_TicketCallback cb, | ||
231 | void *cb_cls); | ||
186 | 232 | ||
187 | /** | 233 | /** |
188 | * Returns string representation of token. A JSON-Web-Token. | 234 | * Revoked an issued ticket. The relying party will be unable to retrieve |
235 | * updated attributes. | ||
189 | * | 236 | * |
190 | * @param token the token | 237 | * @param id the identity provider to use |
191 | * @return The JWT (must be freed) | 238 | * @param identity the issuing identity |
239 | * @param ticket the ticket to revoke | ||
240 | * @param cb the callback | ||
241 | * @param cb_cls the callback closure | ||
242 | * @return handle to abort the operation | ||
192 | */ | 243 | */ |
193 | char * | 244 | struct GNUNET_IDENTITY_PROVIDER_Operation * |
194 | GNUNET_IDENTITY_PROVIDER_token_to_string (const struct GNUNET_IDENTITY_PROVIDER_Token *token); | 245 | GNUNET_IDENTITY_PROVIDER_ticket_revoke (struct GNUNET_IDENTITY_PROVIDER_Handle *id, |
246 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, | ||
247 | const struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket, | ||
248 | GNUNET_IDENTITY_PROVIDER_ContinuationWithStatus cb, | ||
249 | void *cb_cls); | ||
250 | |||
251 | |||
195 | 252 | ||
196 | /** | 253 | /** |
197 | * Returns string representation of ticket. Base64-Encoded | 254 | * Consumes an issued ticket. The ticket is persisted |
255 | * and used to retrieve identity information from the issuer | ||
198 | * | 256 | * |
199 | * @param ticket the ticket | 257 | * @param id the identity provider to use |
200 | * @return the Base64-Encoded ticket | 258 | * @param identity the identity that is the subject of the issued ticket (the audience) |
259 | * @param ticket the issued ticket to consume | ||
260 | * @param cb the callback to call | ||
261 | * @param cb_cls the callback closure | ||
262 | * @return handle to abort the operation | ||
263 | */ | ||
264 | struct GNUNET_IDENTITY_PROVIDER_Operation * | ||
265 | GNUNET_IDENTITY_PROVIDER_ticket_consume (struct GNUNET_IDENTITY_PROVIDER_Handle *id, | ||
266 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, | ||
267 | const struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket, | ||
268 | GNUNET_IDENTITY_PROVIDER_AttributeResult cb, | ||
269 | void *cb_cls); | ||
270 | |||
271 | /** | ||
272 | * Lists all tickets that have been issued to remote | ||
273 | * identites (relying parties) | ||
274 | * | ||
275 | * @param h the identity provider to use | ||
276 | * @param identity the issuing identity | ||
277 | * @param error_cb function to call on error (i.e. disconnect), | ||
278 | * the handle is afterwards invalid | ||
279 | * @param error_cb_cls closure for @a error_cb | ||
280 | * @param proc function to call on each ticket; it | ||
281 | * will be called repeatedly with a value (if available) | ||
282 | * @param proc_cls closure for @a proc | ||
283 | * @param finish_cb function to call on completion | ||
284 | * the handle is afterwards invalid | ||
285 | * @param finish_cb_cls closure for @a finish_cb | ||
286 | * @return an iterator handle to use for iteration | ||
287 | */ | ||
288 | struct GNUNET_IDENTITY_PROVIDER_TicketIterator * | ||
289 | GNUNET_IDENTITY_PROVIDER_ticket_iteration_start (struct GNUNET_IDENTITY_PROVIDER_Handle *h, | ||
290 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, | ||
291 | GNUNET_SCHEDULER_TaskCallback error_cb, | ||
292 | void *error_cb_cls, | ||
293 | GNUNET_IDENTITY_PROVIDER_TicketCallback proc, | ||
294 | void *proc_cls, | ||
295 | GNUNET_SCHEDULER_TaskCallback finish_cb, | ||
296 | void *finish_cb_cls); | ||
297 | |||
298 | /** | ||
299 | * Lists all tickets that have been issued to remote | ||
300 | * identites (relying parties) | ||
301 | * | ||
302 | * @param id the identity provider to use | ||
303 | * @param identity the issuing identity | ||
304 | * @param error_cb function to call on error (i.e. disconnect), | ||
305 | * the handle is afterwards invalid | ||
306 | * @param error_cb_cls closure for @a error_cb | ||
307 | * @param proc function to call on each ticket; it | ||
308 | * will be called repeatedly with a value (if available) | ||
309 | * @param proc_cls closure for @a proc | ||
310 | * @param finish_cb function to call on completion | ||
311 | * the handle is afterwards invalid | ||
312 | * @param finish_cb_cls closure for @a finish_cb | ||
313 | * @return an iterator handle to use for iteration | ||
201 | */ | 314 | */ |
202 | char * | 315 | struct GNUNET_IDENTITY_PROVIDER_TicketIterator * |
203 | GNUNET_IDENTITY_PROVIDER_ticket_to_string (const struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket); | 316 | GNUNET_IDENTITY_PROVIDER_ticket_iteration_start_rp (struct GNUNET_IDENTITY_PROVIDER_Handle *h, |
317 | const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, | ||
318 | GNUNET_SCHEDULER_TaskCallback error_cb, | ||
319 | void *error_cb_cls, | ||
320 | GNUNET_IDENTITY_PROVIDER_TicketCallback proc, | ||
321 | void *proc_cls, | ||
322 | GNUNET_SCHEDULER_TaskCallback finish_cb, | ||
323 | void *finish_cb_cls); | ||
204 | 324 | ||
205 | /** | 325 | /** |
206 | * Created a ticket from a string (Base64 encoded ticket) | 326 | * Calls the record processor specified in #GNUNET_IDENTITY_PROVIDER_ticket_iteration_start |
327 | * for the next record. | ||
207 | * | 328 | * |
208 | * @param input Base64 encoded ticket | 329 | * @param it the iterator |
209 | * @param ticket pointer where the ticket is stored | ||
210 | * @return GNUNET_OK | ||
211 | */ | 330 | */ |
212 | int | 331 | void |
213 | GNUNET_IDENTITY_PROVIDER_string_to_ticket (const char* input, | 332 | GNUNET_IDENTITY_PROVIDER_ticket_iteration_next (struct GNUNET_IDENTITY_PROVIDER_TicketIterator *it); |
214 | struct GNUNET_IDENTITY_PROVIDER_Ticket **ticket); | ||
215 | 333 | ||
216 | /** | 334 | /** |
217 | * Destroys a ticket | 335 | * Stops iteration and releases the idp handle for further calls. Must |
336 | * be called on any iteration that has not yet completed prior to calling | ||
337 | * #GNUNET_IDENTITY_PROVIDER_disconnect. | ||
218 | * | 338 | * |
219 | * @param ticket the ticket to destroy | 339 | * @param it the iterator |
220 | */ | 340 | */ |
221 | void | 341 | void |
222 | GNUNET_IDENTITY_PROVIDER_ticket_destroy(struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket); | 342 | GNUNET_IDENTITY_PROVIDER_ticket_iteration_stop (struct GNUNET_IDENTITY_PROVIDER_TicketIterator *it); |
343 | |||
344 | /** | ||
345 | * Disconnect from identity provider service. | ||
346 | * | ||
347 | * @param h identity provider service to disconnect | ||
348 | */ | ||
349 | void | ||
350 | GNUNET_IDENTITY_PROVIDER_disconnect (struct GNUNET_IDENTITY_PROVIDER_Handle *h); | ||
351 | |||
352 | |||
353 | /** | ||
354 | * Cancel an identity provider operation. Note that the operation MAY still | ||
355 | * be executed; this merely cancels the continuation; if the request | ||
356 | * was already transmitted, the service may still choose to complete | ||
357 | * the operation. | ||
358 | * | ||
359 | * @param op operation to cancel | ||
360 | */ | ||
361 | void | ||
362 | GNUNET_IDENTITY_PROVIDER_cancel (struct GNUNET_IDENTITY_PROVIDER_Operation *op); | ||
223 | 363 | ||
224 | #if 0 /* keep Emacsens' auto-indent happy */ | 364 | #if 0 /* keep Emacsens' auto-indent happy */ |
225 | { | 365 | { |
diff --git a/src/include/gnunet_jsonapi_lib.h b/src/include/gnunet_jsonapi_lib.h index f95bff836..2f6b810f0 100644 --- a/src/include/gnunet_jsonapi_lib.h +++ b/src/include/gnunet_jsonapi_lib.h | |||
@@ -248,7 +248,7 @@ GNUNET_JSONAPI_resource_check_id (const struct GNUNET_JSONAPI_Resource *resource | |||
248 | * @param res the JSON resource | 248 | * @param res the JSON resource |
249 | * @return the resource id | 249 | * @return the resource id |
250 | */ | 250 | */ |
251 | char* | 251 | const char* |
252 | GNUNET_JSONAPI_resource_get_id (const struct GNUNET_JSONAPI_Resource *resource); | 252 | GNUNET_JSONAPI_resource_get_id (const struct GNUNET_JSONAPI_Resource *resource); |
253 | 253 | ||
254 | 254 | ||
diff --git a/src/include/gnunet_protocols.h b/src/include/gnunet_protocols.h index 9cfd00e39..436adc5a4 100644 --- a/src/include/gnunet_protocols.h +++ b/src/include/gnunet_protocols.h | |||
@@ -2628,13 +2628,47 @@ extern "C" | |||
2628 | * | 2628 | * |
2629 | * IDENTITY PROVIDER MESSAGE TYPES | 2629 | * IDENTITY PROVIDER MESSAGE TYPES |
2630 | */ | 2630 | */ |
2631 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_ISSUE 961 | 2631 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_ATTRIBUTE_STORE 961 |
2632 | 2632 | ||
2633 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_EXCHANGE 962 | 2633 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_ATTRIBUTE_STORE_RESPONSE 962 |
2634 | 2634 | ||
2635 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_ISSUE_RESULT 963 | 2635 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_ATTRIBUTE_ITERATION_START 963 |
2636 | 2636 | ||
2637 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_EXCHANGE_RESULT 964 | 2637 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_ATTRIBUTE_ITERATION_STOP 964 |
2638 | |||
2639 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_ATTRIBUTE_ITERATION_NEXT 965 | ||
2640 | |||
2641 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_ATTRIBUTE_RESULT 966 | ||
2642 | |||
2643 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_ISSUE_TICKET 967 | ||
2644 | |||
2645 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_TICKET_RESULT 968 | ||
2646 | |||
2647 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_REVOKE_TICKET 969 | ||
2648 | |||
2649 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_REVOKE_TICKET_RESULT 970 | ||
2650 | |||
2651 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_CONSUME_TICKET 971 | ||
2652 | |||
2653 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_CONSUME_TICKET_RESULT 972 | ||
2654 | |||
2655 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_TICKET_ITERATION_START 973 | ||
2656 | |||
2657 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_TICKET_ITERATION_STOP 974 | ||
2658 | |||
2659 | #define GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_TICKET_ITERATION_NEXT 975 | ||
2660 | |||
2661 | /************************************************** | ||
2662 | * | ||
2663 | * CREDENTIAL MESSAGE TYPES | ||
2664 | */ | ||
2665 | #define GNUNET_MESSAGE_TYPE_CREDENTIAL_VERIFY 981 | ||
2666 | |||
2667 | #define GNUNET_MESSAGE_TYPE_CREDENTIAL_VERIFY_RESULT 982 | ||
2668 | |||
2669 | #define GNUNET_MESSAGE_TYPE_CREDENTIAL_COLLECT 983 | ||
2670 | |||
2671 | #define GNUNET_MESSAGE_TYPE_CREDENTIAL_COLLECT_RESULT 984 | ||
2638 | 2672 | ||
2639 | /******************************************************************************/ | 2673 | /******************************************************************************/ |
2640 | 2674 | ||
diff --git a/src/include/gnunet_signatures.h b/src/include/gnunet_signatures.h index c1e0d005c..03bc4575e 100644 --- a/src/include/gnunet_signatures.h +++ b/src/include/gnunet_signatures.h | |||
@@ -185,6 +185,11 @@ extern "C" | |||
185 | */ | 185 | */ |
186 | #define GNUNET_SIGNATURE_PURPOSE_GNUID_TICKET 27 | 186 | #define GNUNET_SIGNATURE_PURPOSE_GNUID_TICKET 27 |
187 | 187 | ||
188 | /** | ||
189 | * Signature for a GNUnet credential | ||
190 | */ | ||
191 | #define GNUNET_SIGNATURE_PURPOSE_CREDENTIAL 28 | ||
192 | |||
188 | #if 0 /* keep Emacsens' auto-indent happy */ | 193 | #if 0 /* keep Emacsens' auto-indent happy */ |
189 | { | 194 | { |
190 | #endif | 195 | #endif |