← Back to branch summary

~ubuntu-branches/ubuntu/trusty/xulrunner/trusty

« back to all changes in this revision

Viewing changes to security/nss-fips/lib/pki/cryptocontext.c

  • Committer: Bazaar Package Importer
  • Author(s): Devid Antonio Filoni
  • Date: 2008-08-25 13:04:18 UTC
  • mfrom: (1.1.12 upstream)
  • Revision ID: james.westby@ubuntu.com-20080825130418-ck1i2ms384tzb9m0
Tags: 1.8.1.16+nobinonly-0ubuntu1
https://launchpad.net/bugs/254618
* New upstream release (taken from upstream CVS), LP: #254618.
* Fix MFSA 2008-35, MFSA 2008-34, MFSA 2008-33, MFSA 2008-32, MFSA 2008-31,
  MFSA 2008-30, MFSA 2008-29, MFSA 2008-28, MFSA 2008-27, MFSA 2008-25,
  MFSA 2008-24, MFSA 2008-23, MFSA 2008-22, MFSA 2008-21, MFSA 2008-26 also
  known as CVE-2008-2933, CVE-2008-2785, CVE-2008-2811, CVE-2008-2810,
  CVE-2008-2809, CVE-2008-2808, CVE-2008-2807, CVE-2008-2806, CVE-2008-2805,
  CVE-2008-2803, CVE-2008-2802, CVE-2008-2801, CVE-2008-2800, CVE-2008-2798.
* Drop 89_bz419350_attachment_306066 patch, merged upstream.
* Bump Standards-Version to 3.8.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
security/nss-fips/lib/pki/cryptocontext.c
 
1
/* ***** BEGIN LICENSE BLOCK *****
 
2
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 
3
 *
 
4
 * The contents of this file are subject to the Mozilla Public License Version
 
5
 * 1.1 (the "License"); you may not use this file except in compliance with
 
6
 * the License. You may obtain a copy of the License at
 
7
 * http://www.mozilla.org/MPL/
 
8
 *
 
9
 * Software distributed under the License is distributed on an "AS IS" basis,
 
10
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 
11
 * for the specific language governing rights and limitations under the
 
12
 * License.
 
13
 *
 
14
 * The Original Code is the Netscape security libraries.
 
15
 *
 
16
 * The Initial Developer of the Original Code is
 
17
 * Netscape Communications Corporation.
 
18
 * Portions created by the Initial Developer are Copyright (C) 1994-2000
 
19
 * the Initial Developer. All Rights Reserved.
 
20
 *
 
21
 * Contributor(s):
 
22
 *
 
23
 * Alternatively, the contents of this file may be used under the terms of
 
24
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 
25
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 
26
 * in which case the provisions of the GPL or the LGPL are applicable instead
 
27
 * of those above. If you wish to allow use of your version of this file only
 
28
 * under the terms of either the GPL or the LGPL, and not to allow others to
 
29
 * use your version of this file under the terms of the MPL, indicate your
 
30
 * decision by deleting the provisions above and replace them with the notice
 
31
 * and other provisions required by the GPL or the LGPL. If you do not delete
 
32
 * the provisions above, a recipient may use your version of this file under
 
33
 * the terms of any one of the MPL, the GPL or the LGPL.
 
34
 *
 
35
 * ***** END LICENSE BLOCK ***** */
 
36
 
 
37
#ifdef DEBUG
 
38
static const char CVS_ID[] = "@(#) $RCSfile: cryptocontext.c,v $ $Revision: 1.14.28.2 $ $Date: 2006/08/22 17:12:04 $";
 
39
#endif /* DEBUG */
 
40
 
 
41
#ifndef DEV_H
 
42
#include "dev.h"
 
43
#endif /* DEV_H */
 
44
 
 
45
#ifndef PKIM_H
 
46
#include "pkim.h"
 
47
#endif /* PKIM_H */
 
48
 
 
49
#ifndef PKISTORE_H
 
50
#include "pkistore.h"
 
51
#endif /* PKISTORE_H */
 
52
 
 
53
#include "pki1t.h"
 
54
 
 
55
#ifdef PURE_STAN_BUILD
 
56
struct NSSCryptoContextStr
 
57
{
 
58
    PRInt32 refCount;
 
59
    NSSArena *arena;
 
60
    NSSTrustDomain *td;
 
61
    NSSToken *token;
 
62
    nssSession *session;
 
63
    nssCertificateStore *certStore;
 
64
};
 
65
#endif
 
66
 
 
67
extern const NSSError NSS_ERROR_NOT_FOUND;
 
68
extern const NSSError NSS_ERROR_INVALID_ARGUMENT;
 
69
 
 
70
NSS_IMPLEMENT NSSCryptoContext *
 
71
nssCryptoContext_Create (
 
72
  NSSTrustDomain *td,
 
73
  NSSCallback *uhhOpt
 
74
)
 
75
{
 
76
    NSSArena *arena;
 
77
    NSSCryptoContext *rvCC;
 
78
    arena = NSSArena_Create();
 
79
    if (!arena) {
 
80
        return NULL;
 
81
    }
 
82
    rvCC = nss_ZNEW(arena, NSSCryptoContext);
 
83
    if (!rvCC) {
 
84
        return NULL;
 
85
    }
 
86
    rvCC->td = td;
 
87
    rvCC->arena = arena;
 
88
    rvCC->certStore = nssCertificateStore_Create(rvCC->arena);
 
89
    if (!rvCC->certStore) {
 
90
        nssArena_Destroy(arena);
 
91
        return NULL;
 
92
    }
 
93
 
 
94
    return rvCC;
 
95
}
 
96
 
 
97
NSS_IMPLEMENT PRStatus
 
98
NSSCryptoContext_Destroy (
 
99
  NSSCryptoContext *cc
 
100
)
 
101
{
 
102
    PRStatus status = PR_SUCCESS;
 
103
    PORT_Assert(cc->certStore);
 
104
    if (cc->certStore) {
 
105
        status = nssCertificateStore_Destroy(cc->certStore);
 
106
        if (status == PR_FAILURE) {
 
107
            return status;
 
108
        }
 
109
    } else {
 
110
        status = PR_FAILURE;
 
111
    }
 
112
    nssArena_Destroy(cc->arena);
 
113
    return status;
 
114
}
 
115
 
 
116
NSS_IMPLEMENT PRStatus
 
117
NSSCryptoContext_SetDefaultCallback (
 
118
  NSSCryptoContext *td,
 
119
  NSSCallback *newCallback,
 
120
  NSSCallback **oldCallbackOpt
 
121
)
 
122
{
 
123
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
124
    return PR_FAILURE;
 
125
}
 
126
 
 
127
NSS_IMPLEMENT NSSCallback *
 
128
NSSCryptoContext_GetDefaultCallback (
 
129
  NSSCryptoContext *td,
 
130
  PRStatus *statusOpt
 
131
)
 
132
{
 
133
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
134
    return NULL;
 
135
}
 
136
 
 
137
NSS_IMPLEMENT NSSTrustDomain *
 
138
NSSCryptoContext_GetTrustDomain (
 
139
  NSSCryptoContext *td
 
140
)
 
141
{
 
142
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
143
    return NULL;
 
144
}
 
145
 
 
146
 
 
147
NSS_IMPLEMENT NSSCertificate *
 
148
NSSCryptoContext_FindOrImportCertificate (
 
149
  NSSCryptoContext *cc,
 
150
  NSSCertificate *c
 
151
)
 
152
{
 
153
    NSSCertificate *rvCert = NULL;
 
154
 
 
155
    PORT_Assert(cc->certStore);
 
156
    if (!cc->certStore) {
 
157
        nss_SetError(NSS_ERROR_INVALID_ARGUMENT);
 
158
        return rvCert;
 
159
    }
 
160
    rvCert = nssCertificateStore_FindOrAdd(cc->certStore, c);
 
161
    if (rvCert == c && c->object.cryptoContext != cc) {
 
162
        PORT_Assert(!c->object.cryptoContext);
 
163
        c->object.cryptoContext = cc;
 
164
    } 
 
165
    if (rvCert) {
 
166
        /* an NSSCertificate cannot be part of two crypto contexts
 
167
        ** simultaneously.  If this assertion fails, then there is 
 
168
        ** a serious Stan design flaw.
 
169
        */
 
170
        PORT_Assert(cc == c->object.cryptoContext);
 
171
    }
 
172
    return rvCert;
 
173
}
 
174
 
 
175
NSS_IMPLEMENT NSSCertificate *
 
176
NSSCryptoContext_ImportPKIXCertificate (
 
177
  NSSCryptoContext *cc,
 
178
  struct NSSPKIXCertificateStr *pc
 
179
)
 
180
{
 
181
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
182
    return NULL;
 
183
}
 
184
 
 
185
NSS_IMPLEMENT NSSCertificate *
 
186
NSSCryptoContext_ImportEncodedCertificate (
 
187
  NSSCryptoContext *cc,
 
188
  NSSBER *ber
 
189
)
 
190
{
 
191
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
192
    return NULL;
 
193
}
 
194
 
 
195
NSS_IMPLEMENT PRStatus
 
196
NSSCryptoContext_ImportEncodedPKIXCertificateChain (
 
197
  NSSCryptoContext *cc,
 
198
  NSSBER *ber
 
199
)
 
200
{
 
201
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
202
    return PR_FAILURE;
 
203
}
 
204
 
 
205
NSS_IMPLEMENT PRStatus
 
206
nssCryptoContext_ImportTrust (
 
207
  NSSCryptoContext *cc,
 
208
  NSSTrust *trust
 
209
)
 
210
{
 
211
    PRStatus nssrv;
 
212
    PORT_Assert(cc->certStore);
 
213
    if (!cc->certStore) {
 
214
        return PR_FAILURE;
 
215
    }
 
216
    nssrv = nssCertificateStore_AddTrust(cc->certStore, trust);
 
217
#if 0
 
218
    if (nssrv == PR_SUCCESS) {
 
219
        trust->object.cryptoContext = cc;
 
220
    }
 
221
#endif
 
222
    return nssrv;
 
223
}
 
224
 
 
225
NSS_IMPLEMENT PRStatus
 
226
nssCryptoContext_ImportSMIMEProfile (
 
227
  NSSCryptoContext *cc,
 
228
  nssSMIMEProfile *profile
 
229
)
 
230
{
 
231
    PRStatus nssrv;
 
232
    PORT_Assert(cc->certStore);
 
233
    if (!cc->certStore) {
 
234
        return PR_FAILURE;
 
235
    }
 
236
    nssrv = nssCertificateStore_AddSMIMEProfile(cc->certStore, profile);
 
237
#if 0
 
238
    if (nssrv == PR_SUCCESS) {
 
239
        profile->object.cryptoContext = cc;
 
240
    }
 
241
#endif
 
242
    return nssrv;
 
243
}
 
244
 
 
245
NSS_IMPLEMENT NSSCertificate *
 
246
NSSCryptoContext_FindBestCertificateByNickname (
 
247
  NSSCryptoContext *cc,
 
248
  NSSUTF8 *name,
 
249
  NSSTime *timeOpt, /* NULL for "now" */
 
250
  NSSUsage *usage,
 
251
  NSSPolicies *policiesOpt /* NULL for none */
 
252
)
 
253
{
 
254
    NSSCertificate **certs;
 
255
    NSSCertificate *rvCert = NULL;
 
256
    PORT_Assert(cc->certStore);
 
257
    if (!cc->certStore) {
 
258
        return NULL;
 
259
    }
 
260
    certs = nssCertificateStore_FindCertificatesByNickname(cc->certStore,
 
261
                                                           name,
 
262
                                                           NULL, 0, NULL);
 
263
    if (certs) {
 
264
        rvCert = nssCertificateArray_FindBestCertificate(certs,
 
265
                                                         timeOpt,
 
266
                                                         usage,
 
267
                                                         policiesOpt);
 
268
        nssCertificateArray_Destroy(certs);
 
269
    }
 
270
    return rvCert;
 
271
}
 
272
 
 
273
NSS_IMPLEMENT NSSCertificate **
 
274
NSSCryptoContext_FindCertificatesByNickname (
 
275
  NSSCryptoContext *cc,
 
276
  NSSUTF8 *name,
 
277
  NSSCertificate *rvOpt[],
 
278
  PRUint32 maximumOpt, /* 0 for no max */
 
279
  NSSArena *arenaOpt
 
280
)
 
281
{
 
282
    NSSCertificate **rvCerts;
 
283
    PORT_Assert(cc->certStore);
 
284
    if (!cc->certStore) {
 
285
        return NULL;
 
286
    }
 
287
    rvCerts = nssCertificateStore_FindCertificatesByNickname(cc->certStore,
 
288
                                                             name,
 
289
                                                             rvOpt,
 
290
                                                             maximumOpt,
 
291
                                                             arenaOpt);
 
292
    return rvCerts;
 
293
}
 
294
 
 
295
NSS_IMPLEMENT NSSCertificate *
 
296
NSSCryptoContext_FindCertificateByIssuerAndSerialNumber (
 
297
  NSSCryptoContext *cc,
 
298
  NSSDER *issuer,
 
299
  NSSDER *serialNumber
 
300
)
 
301
{
 
302
    PORT_Assert(cc->certStore);
 
303
    if (!cc->certStore) {
 
304
        return NULL;
 
305
    }
 
306
    return nssCertificateStore_FindCertificateByIssuerAndSerialNumber(
 
307
                                                               cc->certStore,
 
308
                                                               issuer,
 
309
                                                               serialNumber);
 
310
}
 
311
 
 
312
NSS_IMPLEMENT NSSCertificate *
 
313
NSSCryptoContext_FindBestCertificateBySubject (
 
314
  NSSCryptoContext *cc,
 
315
  NSSDER *subject,
 
316
  NSSTime *timeOpt,
 
317
  NSSUsage *usage,
 
318
  NSSPolicies *policiesOpt
 
319
)
 
320
{
 
321
    NSSCertificate **certs;
 
322
    NSSCertificate *rvCert = NULL;
 
323
    PORT_Assert(cc->certStore);
 
324
    if (!cc->certStore) {
 
325
        return NULL;
 
326
    }
 
327
    certs = nssCertificateStore_FindCertificatesBySubject(cc->certStore,
 
328
                                                          subject,
 
329
                                                          NULL, 0, NULL);
 
330
    if (certs) {
 
331
        rvCert = nssCertificateArray_FindBestCertificate(certs,
 
332
                                                         timeOpt,
 
333
                                                         usage,
 
334
                                                         policiesOpt);
 
335
        nssCertificateArray_Destroy(certs);
 
336
    }
 
337
    return rvCert;
 
338
}
 
339
 
 
340
NSS_IMPLEMENT NSSCertificate **
 
341
nssCryptoContext_FindCertificatesBySubject (
 
342
  NSSCryptoContext *cc,
 
343
  NSSDER *subject,
 
344
  NSSCertificate *rvOpt[],
 
345
  PRUint32 maximumOpt, /* 0 for no max */
 
346
  NSSArena *arenaOpt
 
347
)
 
348
{
 
349
    NSSCertificate **rvCerts;
 
350
    PORT_Assert(cc->certStore);
 
351
    if (!cc->certStore) {
 
352
        return NULL;
 
353
    }
 
354
    rvCerts = nssCertificateStore_FindCertificatesBySubject(cc->certStore,
 
355
                                                            subject,
 
356
                                                            rvOpt,
 
357
                                                            maximumOpt,
 
358
                                                            arenaOpt);
 
359
    return rvCerts;
 
360
}
 
361
 
 
362
NSS_IMPLEMENT NSSCertificate **
 
363
NSSCryptoContext_FindCertificatesBySubject (
 
364
  NSSCryptoContext *cc,
 
365
  NSSDER *subject,
 
366
  NSSCertificate *rvOpt[],
 
367
  PRUint32 maximumOpt, /* 0 for no max */
 
368
  NSSArena *arenaOpt
 
369
)
 
370
{
 
371
    return nssCryptoContext_FindCertificatesBySubject(cc, subject,
 
372
                                                      rvOpt, maximumOpt,
 
373
                                                      arenaOpt);
 
374
}
 
375
 
 
376
NSS_IMPLEMENT NSSCertificate *
 
377
NSSCryptoContext_FindBestCertificateByNameComponents (
 
378
  NSSCryptoContext *cc,
 
379
  NSSUTF8 *nameComponents,
 
380
  NSSTime *timeOpt,
 
381
  NSSUsage *usage,
 
382
  NSSPolicies *policiesOpt
 
383
)
 
384
{
 
385
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
386
    return NULL;
 
387
}
 
388
 
 
389
NSS_IMPLEMENT NSSCertificate **
 
390
NSSCryptoContext_FindCertificatesByNameComponents (
 
391
  NSSCryptoContext *cc,
 
392
  NSSUTF8 *nameComponents,
 
393
  NSSCertificate *rvOpt[],
 
394
  PRUint32 maximumOpt, /* 0 for no max */
 
395
  NSSArena *arenaOpt
 
396
)
 
397
{
 
398
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
399
    return NULL;
 
400
}
 
401
 
 
402
NSS_IMPLEMENT NSSCertificate *
 
403
NSSCryptoContext_FindCertificateByEncodedCertificate (
 
404
  NSSCryptoContext *cc,
 
405
  NSSBER *encodedCertificate
 
406
)
 
407
{
 
408
    PORT_Assert(cc->certStore);
 
409
    if (!cc->certStore) {
 
410
        return NULL;
 
411
    }
 
412
    return nssCertificateStore_FindCertificateByEncodedCertificate(
 
413
                                                           cc->certStore,
 
414
                                                           encodedCertificate);
 
415
}
 
416
 
 
417
NSS_IMPLEMENT NSSCertificate *
 
418
NSSCryptoContext_FindBestCertificateByEmail (
 
419
  NSSCryptoContext *cc,
 
420
  NSSASCII7 *email,
 
421
  NSSTime *timeOpt,
 
422
  NSSUsage *usage,
 
423
  NSSPolicies *policiesOpt
 
424
)
 
425
{
 
426
    NSSCertificate **certs;
 
427
    NSSCertificate *rvCert = NULL;
 
428
 
 
429
    PORT_Assert(cc->certStore);
 
430
    if (!cc->certStore) {
 
431
        return NULL;
 
432
    }
 
433
    certs = nssCertificateStore_FindCertificatesByEmail(cc->certStore,
 
434
                                                        email,
 
435
                                                        NULL, 0, NULL);
 
436
    if (certs) {
 
437
        rvCert = nssCertificateArray_FindBestCertificate(certs,
 
438
                                                         timeOpt,
 
439
                                                         usage,
 
440
                                                         policiesOpt);
 
441
        nssCertificateArray_Destroy(certs);
 
442
    }
 
443
    return rvCert;
 
444
}
 
445
 
 
446
NSS_IMPLEMENT NSSCertificate **
 
447
NSSCryptoContext_FindCertificatesByEmail (
 
448
  NSSCryptoContext *cc,
 
449
  NSSASCII7 *email,
 
450
  NSSCertificate *rvOpt[],
 
451
  PRUint32 maximumOpt, /* 0 for no max */
 
452
  NSSArena *arenaOpt
 
453
)
 
454
{
 
455
    NSSCertificate **rvCerts;
 
456
    PORT_Assert(cc->certStore);
 
457
    if (!cc->certStore) {
 
458
        return NULL;
 
459
    }
 
460
    rvCerts = nssCertificateStore_FindCertificatesByEmail(cc->certStore,
 
461
                                                          email,
 
462
                                                          rvOpt,
 
463
                                                          maximumOpt,
 
464
                                                          arenaOpt);
 
465
    return rvCerts;
 
466
}
 
467
 
 
468
NSS_IMPLEMENT NSSCertificate *
 
469
NSSCryptoContext_FindCertificateByOCSPHash (
 
470
  NSSCryptoContext *cc,
 
471
  NSSItem *hash
 
472
)
 
473
{
 
474
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
475
    return NULL;
 
476
}
 
477
 
 
478
NSS_IMPLEMENT NSSCertificate *
 
479
NSSCryptoContext_FindBestUserCertificate (
 
480
  NSSCryptoContext *cc,
 
481
  NSSTime *timeOpt,
 
482
  NSSUsage *usage,
 
483
  NSSPolicies *policiesOpt
 
484
)
 
485
{
 
486
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
487
    return NULL;
 
488
}
 
489
 
 
490
NSS_IMPLEMENT NSSCertificate **
 
491
NSSCryptoContext_FindUserCertificates (
 
492
  NSSCryptoContext *cc,
 
493
  NSSTime *timeOpt,
 
494
  NSSUsage *usageOpt,
 
495
  NSSPolicies *policiesOpt,
 
496
  NSSCertificate **rvOpt,
 
497
  PRUint32 rvLimit, /* zero for no limit */
 
498
  NSSArena *arenaOpt
 
499
)
 
500
{
 
501
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
502
    return NULL;
 
503
}
 
504
 
 
505
NSS_IMPLEMENT NSSCertificate *
 
506
NSSCryptoContext_FindBestUserCertificateForSSLClientAuth (
 
507
  NSSCryptoContext *cc,
 
508
  NSSUTF8 *sslHostOpt,
 
509
  NSSDER *rootCAsOpt[], /* null pointer for none */
 
510
  PRUint32 rootCAsMaxOpt, /* zero means list is null-terminated */
 
511
  NSSAlgorithmAndParameters *apOpt,
 
512
  NSSPolicies *policiesOpt
 
513
)
 
514
{
 
515
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
516
    return NULL;
 
517
}
 
518
 
 
519
NSS_IMPLEMENT NSSCertificate **
 
520
NSSCryptoContext_FindUserCertificatesForSSLClientAuth (
 
521
  NSSCryptoContext *cc,
 
522
  NSSUTF8 *sslHostOpt,
 
523
  NSSDER *rootCAsOpt[], /* null pointer for none */
 
524
  PRUint32 rootCAsMaxOpt, /* zero means list is null-terminated */
 
525
  NSSAlgorithmAndParameters *apOpt,
 
526
  NSSPolicies *policiesOpt,
 
527
  NSSCertificate **rvOpt,
 
528
  PRUint32 rvLimit, /* zero for no limit */
 
529
  NSSArena *arenaOpt
 
530
)
 
531
{
 
532
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
533
    return NULL;
 
534
}
 
535
 
 
536
NSS_IMPLEMENT NSSCertificate *
 
537
NSSCryptoContext_FindBestUserCertificateForEmailSigning (
 
538
  NSSCryptoContext *cc,
 
539
  NSSASCII7 *signerOpt,
 
540
  NSSASCII7 *recipientOpt,
 
541
  /* anything more here? */
 
542
  NSSAlgorithmAndParameters *apOpt,
 
543
  NSSPolicies *policiesOpt
 
544
)
 
545
{
 
546
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
547
    return NULL;
 
548
}
 
549
 
 
550
NSS_IMPLEMENT NSSCertificate *
 
551
NSSCryptoContext_FindUserCertificatesForEmailSigning (
 
552
  NSSCryptoContext *cc,
 
553
  NSSASCII7 *signerOpt, /* fgmr or a more general name? */
 
554
  NSSASCII7 *recipientOpt,
 
555
  /* anything more here? */
 
556
  NSSAlgorithmAndParameters *apOpt,
 
557
  NSSPolicies *policiesOpt,
 
558
  NSSCertificate **rvOpt,
 
559
  PRUint32 rvLimit, /* zero for no limit */
 
560
  NSSArena *arenaOpt
 
561
)
 
562
{
 
563
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
564
    return NULL;
 
565
}
 
566
 
 
567
NSS_IMPLEMENT NSSTrust *
 
568
nssCryptoContext_FindTrustForCertificate (
 
569
  NSSCryptoContext *cc,
 
570
  NSSCertificate *cert
 
571
)
 
572
{
 
573
    PORT_Assert(cc->certStore);
 
574
    if (!cc->certStore) {
 
575
        return NULL;
 
576
    }
 
577
    return nssCertificateStore_FindTrustForCertificate(cc->certStore, cert);
 
578
}
 
579
 
 
580
NSS_IMPLEMENT nssSMIMEProfile *
 
581
nssCryptoContext_FindSMIMEProfileForCertificate (
 
582
  NSSCryptoContext *cc,
 
583
  NSSCertificate *cert
 
584
)
 
585
{
 
586
    PORT_Assert(cc->certStore);
 
587
    if (!cc->certStore) {
 
588
        return NULL;
 
589
    }
 
590
    return nssCertificateStore_FindSMIMEProfileForCertificate(cc->certStore, 
 
591
                                                              cert);
 
592
}
 
593
 
 
594
NSS_IMPLEMENT PRStatus
 
595
NSSCryptoContext_GenerateKeyPair (
 
596
  NSSCryptoContext *cc,
 
597
  NSSAlgorithmAndParameters *ap,
 
598
  NSSPrivateKey **pvkOpt,
 
599
  NSSPublicKey **pbkOpt,
 
600
  PRBool privateKeyIsSensitive,
 
601
  NSSToken *destination,
 
602
  NSSCallback *uhhOpt
 
603
)
 
604
{
 
605
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
606
    return PR_FAILURE;
 
607
}
 
608
 
 
609
NSS_IMPLEMENT NSSSymmetricKey *
 
610
NSSCryptoContext_GenerateSymmetricKey (
 
611
  NSSCryptoContext *cc,
 
612
  NSSAlgorithmAndParameters *ap,
 
613
  PRUint32 keysize,
 
614
  NSSToken *destination,
 
615
  NSSCallback *uhhOpt
 
616
)
 
617
{
 
618
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
619
    return NULL;
 
620
}
 
621
 
 
622
NSS_IMPLEMENT NSSSymmetricKey *
 
623
NSSCryptoContext_GenerateSymmetricKeyFromPassword (
 
624
  NSSCryptoContext *cc,
 
625
  NSSAlgorithmAndParameters *ap,
 
626
  NSSUTF8 *passwordOpt, /* if null, prompt */
 
627
  NSSToken *destinationOpt,
 
628
  NSSCallback *uhhOpt
 
629
)
 
630
{
 
631
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
632
    return NULL;
 
633
}
 
634
 
 
635
NSS_IMPLEMENT NSSSymmetricKey *
 
636
NSSCryptoContext_FindSymmetricKeyByAlgorithmAndKeyID (
 
637
  NSSCryptoContext *cc,
 
638
  NSSOID *algorithm,
 
639
  NSSItem *keyID,
 
640
  NSSCallback *uhhOpt
 
641
)
 
642
{
 
643
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
644
    return NULL;
 
645
}
 
646
 
 
647
struct token_session_str {
 
648
    NSSToken *token;
 
649
    nssSession *session;
 
650
};
 
651
 
 
652
NSS_IMPLEMENT NSSItem *
 
653
NSSCryptoContext_Decrypt (
 
654
  NSSCryptoContext *cc,
 
655
  NSSAlgorithmAndParameters *apOpt,
 
656
  NSSItem *encryptedData,
 
657
  NSSCallback *uhhOpt,
 
658
  NSSItem *rvOpt,
 
659
  NSSArena *arenaOpt
 
660
)
 
661
{
 
662
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
663
    return NULL;
 
664
}
 
665
 
 
666
NSS_IMPLEMENT PRStatus
 
667
NSSCryptoContext_BeginDecrypt (
 
668
  NSSCryptoContext *cc,
 
669
  NSSAlgorithmAndParameters *apOpt,
 
670
  NSSCallback *uhhOpt
 
671
)
 
672
{
 
673
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
674
    return PR_FAILURE;
 
675
}
 
676
 
 
677
NSS_IMPLEMENT NSSItem *
 
678
NSSCryptoContext_ContinueDecrypt (
 
679
  NSSCryptoContext *cc,
 
680
  NSSItem *data,
 
681
  NSSItem *rvOpt,
 
682
  NSSArena *arenaOpt
 
683
)
 
684
{
 
685
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
686
    return NULL;
 
687
}
 
688
 
 
689
NSS_IMPLEMENT NSSItem *
 
690
NSSCryptoContext_FinishDecrypt (
 
691
  NSSCryptoContext *cc,
 
692
  NSSItem *rvOpt,
 
693
  NSSArena *arenaOpt
 
694
)
 
695
{
 
696
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
697
    return NULL;
 
698
}
 
699
 
 
700
NSS_IMPLEMENT NSSItem *
 
701
NSSCryptoContext_Sign (
 
702
  NSSCryptoContext *cc,
 
703
  NSSAlgorithmAndParameters *apOpt,
 
704
  NSSItem *data,
 
705
  NSSCallback *uhhOpt,
 
706
  NSSItem *rvOpt,
 
707
  NSSArena *arenaOpt
 
708
)
 
709
{
 
710
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
711
    return NULL;
 
712
}
 
713
 
 
714
NSS_IMPLEMENT PRStatus
 
715
NSSCryptoContext_BeginSign (
 
716
  NSSCryptoContext *cc,
 
717
  NSSAlgorithmAndParameters *apOpt,
 
718
  NSSCallback *uhhOpt
 
719
)
 
720
{
 
721
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
722
    return PR_FAILURE;
 
723
}
 
724
 
 
725
NSS_IMPLEMENT PRStatus
 
726
NSSCryptoContext_ContinueSign (
 
727
  NSSCryptoContext *cc,
 
728
  NSSItem *data
 
729
)
 
730
{
 
731
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
732
    return PR_FAILURE;
 
733
}
 
734
 
 
735
NSS_IMPLEMENT NSSItem *
 
736
NSSCryptoContext_FinishSign (
 
737
  NSSCryptoContext *cc,
 
738
  NSSItem *rvOpt,
 
739
  NSSArena *arenaOpt
 
740
)
 
741
{
 
742
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
743
    return NULL;
 
744
}
 
745
 
 
746
NSS_IMPLEMENT NSSItem *
 
747
NSSCryptoContext_SignRecover (
 
748
  NSSCryptoContext *cc,
 
749
  NSSAlgorithmAndParameters *apOpt,
 
750
  NSSItem *data,
 
751
  NSSCallback *uhhOpt,
 
752
  NSSItem *rvOpt,
 
753
  NSSArena *arenaOpt
 
754
)
 
755
{
 
756
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
757
    return NULL;
 
758
}
 
759
 
 
760
NSS_IMPLEMENT PRStatus
 
761
NSSCryptoContext_BeginSignRecover (
 
762
  NSSCryptoContext *cc,
 
763
  NSSAlgorithmAndParameters *apOpt,
 
764
  NSSCallback *uhhOpt
 
765
)
 
766
{
 
767
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
768
    return PR_FAILURE;
 
769
}
 
770
 
 
771
NSS_IMPLEMENT NSSItem *
 
772
NSSCryptoContext_ContinueSignRecover (
 
773
  NSSCryptoContext *cc,
 
774
  NSSItem *data,
 
775
  NSSItem *rvOpt,
 
776
  NSSArena *arenaOpt
 
777
)
 
778
{
 
779
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
780
    return NULL;
 
781
}
 
782
 
 
783
NSS_IMPLEMENT NSSItem *
 
784
NSSCryptoContext_FinishSignRecover (
 
785
  NSSCryptoContext *cc,
 
786
  NSSItem *rvOpt,
 
787
  NSSArena *arenaOpt
 
788
)
 
789
{
 
790
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
791
    return NULL;
 
792
}
 
793
 
 
794
NSS_IMPLEMENT NSSSymmetricKey *
 
795
NSSCryptoContext_UnwrapSymmetricKey (
 
796
  NSSCryptoContext *cc,
 
797
  NSSAlgorithmAndParameters *apOpt,
 
798
  NSSItem *wrappedKey,
 
799
  NSSCallback *uhhOpt
 
800
)
 
801
{
 
802
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
803
    return NULL;
 
804
}
 
805
 
 
806
NSS_IMPLEMENT NSSSymmetricKey *
 
807
NSSCryptoContext_DeriveSymmetricKey (
 
808
  NSSCryptoContext *cc,
 
809
  NSSPublicKey *bk,
 
810
  NSSAlgorithmAndParameters *apOpt,
 
811
  NSSOID *target,
 
812
  PRUint32 keySizeOpt, /* zero for best allowed */
 
813
  NSSOperations operations,
 
814
  NSSCallback *uhhOpt
 
815
)
 
816
{
 
817
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
818
    return NULL;
 
819
}
 
820
 
 
821
NSS_IMPLEMENT NSSItem *
 
822
NSSCryptoContext_Encrypt (
 
823
  NSSCryptoContext *cc,
 
824
  NSSAlgorithmAndParameters *apOpt,
 
825
  NSSItem *data,
 
826
  NSSCallback *uhhOpt,
 
827
  NSSItem *rvOpt,
 
828
  NSSArena *arenaOpt
 
829
)
 
830
{
 
831
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
832
    return NULL;
 
833
}
 
834
 
 
835
NSS_IMPLEMENT PRStatus
 
836
NSSCryptoContext_BeginEncrypt (
 
837
  NSSCryptoContext *cc,
 
838
  NSSAlgorithmAndParameters *apOpt,
 
839
  NSSCallback *uhhOpt
 
840
)
 
841
{
 
842
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
843
    return PR_FAILURE;
 
844
}
 
845
 
 
846
NSS_IMPLEMENT NSSItem *
 
847
NSSCryptoContext_ContinueEncrypt (
 
848
  NSSCryptoContext *cc,
 
849
  NSSItem *data,
 
850
  NSSItem *rvOpt,
 
851
  NSSArena *arenaOpt
 
852
)
 
853
{
 
854
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
855
    return NULL;
 
856
}
 
857
 
 
858
NSS_IMPLEMENT NSSItem *
 
859
NSSCryptoContext_FinishEncrypt (
 
860
  NSSCryptoContext *cc,
 
861
  NSSItem *rvOpt,
 
862
  NSSArena *arenaOpt
 
863
)
 
864
{
 
865
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
866
    return NULL;
 
867
}
 
868
 
 
869
NSS_IMPLEMENT PRStatus
 
870
NSSCryptoContext_Verify (
 
871
  NSSCryptoContext *cc,
 
872
  NSSAlgorithmAndParameters *apOpt,
 
873
  NSSItem *data,
 
874
  NSSItem *signature,
 
875
  NSSCallback *uhhOpt
 
876
)
 
877
{
 
878
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
879
    return PR_FAILURE;
 
880
}
 
881
 
 
882
NSS_IMPLEMENT PRStatus
 
883
NSSCryptoContext_BeginVerify (
 
884
  NSSCryptoContext *cc,
 
885
  NSSAlgorithmAndParameters *apOpt,
 
886
  NSSItem *signature,
 
887
  NSSCallback *uhhOpt
 
888
)
 
889
{
 
890
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
891
    return PR_FAILURE;
 
892
}
 
893
 
 
894
NSS_IMPLEMENT PRStatus
 
895
NSSCryptoContext_ContinueVerify (
 
896
  NSSCryptoContext *cc,
 
897
  NSSItem *data
 
898
)
 
899
{
 
900
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
901
    return PR_FAILURE;
 
902
}
 
903
 
 
904
NSS_IMPLEMENT PRStatus
 
905
NSSCryptoContext_FinishVerify (
 
906
  NSSCryptoContext *cc
 
907
)
 
908
{
 
909
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
910
    return PR_FAILURE;
 
911
}
 
912
 
 
913
NSS_IMPLEMENT NSSItem *
 
914
NSSCryptoContext_VerifyRecover (
 
915
  NSSCryptoContext *cc,
 
916
  NSSAlgorithmAndParameters *apOpt,
 
917
  NSSItem *signature,
 
918
  NSSCallback *uhhOpt,
 
919
  NSSItem *rvOpt,
 
920
  NSSArena *arenaOpt
 
921
)
 
922
{
 
923
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
924
    return NULL;
 
925
}
 
926
 
 
927
NSS_IMPLEMENT PRStatus
 
928
NSSCryptoContext_BeginVerifyRecover (
 
929
  NSSCryptoContext *cc,
 
930
  NSSAlgorithmAndParameters *apOpt,
 
931
  NSSCallback *uhhOpt
 
932
)
 
933
{
 
934
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
935
    return PR_FAILURE;
 
936
}
 
937
 
 
938
NSS_IMPLEMENT NSSItem *
 
939
NSSCryptoContext_ContinueVerifyRecover (
 
940
  NSSCryptoContext *cc,
 
941
  NSSItem *data,
 
942
  NSSItem *rvOpt,
 
943
  NSSArena *arenaOpt
 
944
)
 
945
{
 
946
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
947
    return NULL;
 
948
}
 
949
 
 
950
NSS_IMPLEMENT NSSItem *
 
951
NSSCryptoContext_FinishVerifyRecover (
 
952
  NSSCryptoContext *cc,
 
953
  NSSItem *rvOpt,
 
954
  NSSArena *arenaOpt
 
955
)
 
956
{
 
957
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
958
    return NULL;
 
959
}
 
960
 
 
961
NSS_IMPLEMENT NSSItem *
 
962
NSSCryptoContext_WrapSymmetricKey (
 
963
  NSSCryptoContext *cc,
 
964
  NSSAlgorithmAndParameters *apOpt,
 
965
  NSSSymmetricKey *keyToWrap,
 
966
  NSSCallback *uhhOpt,
 
967
  NSSItem *rvOpt,
 
968
  NSSArena *arenaOpt
 
969
)
 
970
{
 
971
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
972
    return NULL;
 
973
}
 
974
 
 
975
NSS_IMPLEMENT NSSItem *
 
976
NSSCryptoContext_Digest (
 
977
  NSSCryptoContext *cc,
 
978
  NSSAlgorithmAndParameters *apOpt,
 
979
  NSSItem *data,
 
980
  NSSCallback *uhhOpt,
 
981
  NSSItem *rvOpt,
 
982
  NSSArena *arenaOpt
 
983
)
 
984
{
 
985
    return nssToken_Digest(cc->token, cc->session, apOpt, 
 
986
                           data, rvOpt, arenaOpt);
 
987
}
 
988
 
 
989
NSS_IMPLEMENT PRStatus
 
990
NSSCryptoContext_BeginDigest (
 
991
  NSSCryptoContext *cc,
 
992
  NSSAlgorithmAndParameters *apOpt,
 
993
  NSSCallback *uhhOpt
 
994
)
 
995
{
 
996
    return nssToken_BeginDigest(cc->token, cc->session, apOpt);
 
997
}
 
998
 
 
999
NSS_IMPLEMENT PRStatus
 
1000
NSSCryptoContext_ContinueDigest (
 
1001
  NSSCryptoContext *cc,
 
1002
  NSSAlgorithmAndParameters *apOpt,
 
1003
  NSSItem *item
 
1004
)
 
1005
{
 
1006
        /*
 
1007
    NSSAlgorithmAndParameters *ap;
 
1008
    ap = (apOpt) ? apOpt : cc->ap;
 
1009
    */
 
1010
        /* why apOpt?  can't change it at this point... */
 
1011
    return nssToken_ContinueDigest(cc->token, cc->session, item);
 
1012
}
 
1013
 
 
1014
NSS_IMPLEMENT NSSItem *
 
1015
NSSCryptoContext_FinishDigest (
 
1016
  NSSCryptoContext *cc,
 
1017
  NSSItem *rvOpt,
 
1018
  NSSArena *arenaOpt
 
1019
)
 
1020
{
 
1021
    return nssToken_FinishDigest(cc->token, cc->session, rvOpt, arenaOpt);
 
1022
}
 
1023
 
 
1024
NSS_IMPLEMENT NSSCryptoContext *
 
1025
NSSCryptoContext_Clone (
 
1026
  NSSCryptoContext *cc
 
1027
)
 
1028
{
 
1029
    nss_SetError(NSS_ERROR_NOT_FOUND);
 
1030
    return NULL;
 
1031
}
 
1032