Back to index

lightning-sunbird  0.9+nobinonly
Classes | Enumerations | Functions | Variables
smimeutil.c File Reference
#include "secmime.h"
#include "secoid.h"
#include "pk11func.h"
#include "ciferfam.h"
#include "secasn1.h"
#include "secitem.h"
#include "cert.h"
#include "key.h"
#include "secerr.h"
#include "cms.h"
#include "nss.h"

Go to the source code of this file.

Classes

struct  NSSSMIMECapability
struct  NSSSMIMEEncryptionKeyPreference
struct  smime_cipher_map_entry
union  NSSSMIMEEncryptionKeyPreference.id

Enumerations

enum  NSSSMIMEEncryptionKeyPrefSelector {
  NSSSMIMEEncryptionKeyPref_IssuerSN, NSSSMIMEEncryptionKeyPref_RKeyID, NSSSMIMEEncryptionKeyPref_SubjectKeyID, NSSSMIMEEncryptionKeyPref_IssuerSN,
  NSSSMIMEEncryptionKeyPref_RKeyID, NSSSMIMEEncryptionKeyPref_SubjectKeyID
}

Functions

static int smime_mapi_by_cipher (unsigned long cipher)
SECStatus NSS_SMIMEUtil_EnableCipher (unsigned long which, PRBool on)
SECStatus NSS_SMIMEUtil_AllowCipher (unsigned long which, PRBool on)
static SECStatus nss_smime_get_cipher_for_alg_and_key (SECAlgorithmID *algid, PK11SymKey *key, unsigned long *cipher)
static PRBool nss_smime_cipher_allowed (unsigned long which)
PRBool NSS_SMIMEUtil_DecryptionAllowed (SECAlgorithmID *algid, PK11SymKey *key)
PRBool NSS_SMIMEUtil_EncryptionPossible (void)
static int nss_SMIME_FindCipherForSMIMECap (NSSSMIMECapability *cap)
static long smime_choose_cipher (CERTCertificate *scert, CERTCertificate **rcerts)
static int smime_keysize_by_cipher (unsigned long which)
SECStatus NSS_SMIMEUtil_FindBulkAlgForRecipients (CERTCertificate **rcerts, SECOidTag *bulkalgtag, int *keysize)
SECStatus NSS_SMIMEUtil_CreateSMIMECapabilities (PLArenaPool *poolp, SECItem *dest, PRBool includeFortezzaCiphers)
SECStatus NSS_SMIMEUtil_CreateSMIMEEncKeyPrefs (PLArenaPool *poolp, SECItem *dest, CERTCertificate *cert)
SECStatus NSS_SMIMEUtil_CreateMSSMIMEEncKeyPrefs (PLArenaPool *poolp, SECItem *dest, CERTCertificate *cert)
CERTCertificate * NSS_SMIMEUtil_GetCertFromEncryptionKeyPreference (CERTCertDBHandle *certdb, SECItem *DERekp)
PRBool NSSSMIME_VersionCheck (const char *importedVersion)

Variables

static unsigned char asn1_int40 [] = { SEC_ASN1_INTEGER, 0x01, 0x28 }
static unsigned char asn1_int64 [] = { SEC_ASN1_INTEGER, 0x01, 0x40 }
static unsigned char asn1_int128 [] = { SEC_ASN1_INTEGER, 0x02, 0x00, 0x80 }
static SECItem param_int40 = { siBuffer, asn1_int40, sizeof(asn1_int40) }
static SECItem param_int64 = { siBuffer, asn1_int64, sizeof(asn1_int64) }
static SECItem param_int128 = { siBuffer, asn1_int128, sizeof(asn1_int128) }
static const SEC_ASN1Template NSSSMIMECapabilityTemplate []
static const SEC_ASN1Template NSSSMIMECapabilitiesTemplate []
const SEC_ASN1Template NSSCMSRecipientKeyIdentifierTemplate []
static const SEC_ASN1Template smime_encryptionkeypref_template []
static smime_cipher_map_entry smime_cipher_map []
static const int smime_cipher_map_count = sizeof(smime_cipher_map) / sizeof(smime_cipher_map_entry)
const char __nss_smime_rcsid []
const char __nss_smime_sccsid []

Class Documentation

struct NSSSMIMECapability

Definition at line 74 of file smimeutil.c.

Class Members
SECItem capabilityID
long cipher
SECItem parameters
struct NSSSMIMEEncryptionKeyPreference

Definition at line 104 of file smimeutil.c.

Class Members
union
NSSSMIMEEncryptionKeyPreference
id
union
NSSSMIMEEncryptionKeyPreference
id
NSSSMIMEEncryptionKeyPrefSelector selector
struct smime_cipher_map_entry

Definition at line 138 of file smimeutil.c.

Class Members
SECOidTag algtag
PRBool allowed
unsigned long cipher
PRBool enabled
SECItem * parms
union NSSSMIMEEncryptionKeyPreference.id

Definition at line 106 of file smimeutil.c.

Class Members
CERTIssuerAndSN * issuerAndSN
NSSCMSRecipientKeyIdentifier * recipientKeyID
SECItem * subjectKeyID

Enumeration Type Documentation

Enumerator:
NSSSMIMEEncryptionKeyPref_IssuerSN 
NSSSMIMEEncryptionKeyPref_RKeyID 
NSSSMIMEEncryptionKeyPref_SubjectKeyID 
NSSSMIMEEncryptionKeyPref_IssuerSN 
NSSSMIMEEncryptionKeyPref_RKeyID 
NSSSMIMEEncryptionKeyPref_SubjectKeyID 

Definition at line 98 of file smimeutil.c.


Function Documentation

static PRBool nss_smime_cipher_allowed ( unsigned long  which) [static]

Definition at line 283 of file smimeutil.c.

{
    int mapi;

    mapi = smime_mapi_by_cipher(which);
    if (mapi < 0)
       return PR_FALSE;
    return smime_cipher_map[mapi].allowed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 337 of file smimeutil.c.

{
    int i;
    SECOidTag capIDTag;

    /* we need the OIDTag here */
    capIDTag = SECOID_FindOIDTag(&(cap->capabilityID));

    /* go over all the SMIME ciphers we know and see if we find a match */
    for (i = 0; i < smime_cipher_map_count; i++) {
       if (smime_cipher_map[i].algtag != capIDTag)
           continue;
       /*
        * XXX If SECITEM_CompareItem allowed NULLs as arguments (comparing
        * 2 NULLs as equal and NULL and non-NULL as not equal), we could
        * use that here instead of all of the following comparison code.
        */
       if (!smime_cipher_map[i].parms) { 
           if (!cap->parameters.data || !cap->parameters.len)
              break; /* both empty: bingo */
           if (cap->parameters.len     == 2  &&
               cap->parameters.data[0] == SEC_ASN1_NULL &&
              cap->parameters.data[1] == 0) 
              break;  /* DER NULL == NULL, bingo */
       } else if (cap->parameters.data != NULL && 
           cap->parameters.len == smime_cipher_map[i].parms->len &&
           PORT_Memcmp (cap->parameters.data, smime_cipher_map[i].parms->data,
                          cap->parameters.len) == 0)
       {
           break;    /* both not empty, same length & equal content: bingo */
       }
    }

    if (i == smime_cipher_map_count)
       return 0;                          /* no match found */
    return smime_cipher_map[i].cipher;    /* match found, point to cipher */
}

Here is the call graph for this function:

Here is the caller graph for this function:

static SECStatus nss_smime_get_cipher_for_alg_and_key ( SECAlgorithmID *  algid,
PK11SymKey *  key,
unsigned long cipher 
) [static]

Definition at line 242 of file smimeutil.c.

{
    SECOidTag algtag;
    unsigned int keylen_bits;
    unsigned long c;

    algtag = SECOID_GetAlgorithmTag(algid);
    switch (algtag) {
    case SEC_OID_RC2_CBC:
       keylen_bits = PK11_GetKeyStrength(key, algid);
       switch (keylen_bits) {
       case 40:
           c = SMIME_RC2_CBC_40;
           break;
       case 64:
           c = SMIME_RC2_CBC_64;
           break;
       case 128:
           c = SMIME_RC2_CBC_128;
           break;
       default:
           return SECFailure;
       }
       break;
    case SEC_OID_DES_CBC:
       c = SMIME_DES_CBC_56;
       break;
    case SEC_OID_DES_EDE3_CBC:
       c = SMIME_DES_EDE3_168;
       break;
    case SEC_OID_FORTEZZA_SKIPJACK:
       c = SMIME_FORTEZZA;
       break;
    default:
       return SECFailure;
    }
    *cipher = c;
    return SECSuccess;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SECStatus NSS_SMIMEUtil_AllowCipher ( unsigned long  which,
PRBool  on 
)

Definition at line 212 of file smimeutil.c.

{
    unsigned long mask;
    int mapi;

    mask = which & CIPHER_FAMILYID_MASK;

    PORT_Assert (mask == CIPHER_FAMILYID_SMIME);
    if (mask != CIPHER_FAMILYID_SMIME)
       /* XXX set an error! */
       return SECFailure;

    mapi = smime_mapi_by_cipher(which);
    if (mapi < 0)
       /* XXX set an error */
       return SECFailure;

    if (smime_cipher_map[mapi].allowed != on)
       smime_cipher_map[mapi].allowed = on;

    return SECSuccess;
}

Here is the call graph for this function:

SECStatus NSS_SMIMEUtil_CreateMSSMIMEEncKeyPrefs ( PLArenaPool poolp,
SECItem *  dest,
CERTCertificate *  cert 
)

Definition at line 700 of file smimeutil.c.

{
    SECItem *dummy = NULL;
    PLArenaPool *tmppoolp = NULL;
    CERTIssuerAndSN *isn;

    if (cert == NULL)
       goto loser;

    tmppoolp = PORT_NewArena(1024);
    if (tmppoolp == NULL)
       goto loser;

    isn = CERT_GetCertIssuerAndSN(tmppoolp, cert);
    if (isn == NULL)
       goto loser;

    dummy = SEC_ASN1EncodeItem(poolp, dest, isn, SEC_ASN1_GET(CERT_IssuerAndSNTemplate));

loser:
    if (tmppoolp) PORT_FreeArena(tmppoolp, PR_FALSE);

    return (dummy == NULL) ? SECFailure : SECSuccess;
}
SECStatus NSS_SMIMEUtil_CreateSMIMECapabilities ( PLArenaPool poolp,
SECItem *  dest,
PRBool  includeFortezzaCiphers 
)

Definition at line 589 of file smimeutil.c.

{
    NSSSMIMECapability *cap;
    NSSSMIMECapability **smime_capabilities;
    smime_cipher_map_entry *map;
    SECOidData *oiddata;
    SECItem *dummy;
    int i, capIndex;

    /* if we have an old NSSSMIMECapability array, we'll reuse it (has the right size) */
    /* smime_cipher_map_count + 1 is an upper bound - we might end up with less */
    smime_capabilities = (NSSSMIMECapability **)PORT_ZAlloc((smime_cipher_map_count + 1)
                                  * sizeof(NSSSMIMECapability *));
    if (smime_capabilities == NULL)
       return SECFailure;

    capIndex = 0;

    /* Add all the symmetric ciphers
     * We walk the cipher list backwards, as it is ordered by increasing strength,
     * we prefer the stronger cipher over a weaker one, and we have to list the
     * preferred algorithm first */
    for (i = smime_cipher_map_count - 1; i >= 0; i--) {
       /* Find the corresponding entry in the cipher map. */
       map = &(smime_cipher_map[i]);
       if (!map->enabled)
           continue;

       /* If we're using a non-Fortezza cert, only advertise non-Fortezza
          capabilities. (We advertise all capabilities if we have a 
          Fortezza cert.) */
       if ((!includeFortezzaCiphers) && (map->cipher == SMIME_FORTEZZA))
           continue;

       /* get next SMIME capability */
       cap = (NSSSMIMECapability *)PORT_ZAlloc(sizeof(NSSSMIMECapability));
       if (cap == NULL)
           break;
       smime_capabilities[capIndex++] = cap;

       oiddata = SECOID_FindOIDByTag(map->algtag);
       if (oiddata == NULL)
           break;

       cap->capabilityID.data = oiddata->oid.data;
       cap->capabilityID.len = oiddata->oid.len;
       cap->parameters.data = map->parms ? map->parms->data : NULL;
       cap->parameters.len = map->parms ? map->parms->len : 0;
       cap->cipher = smime_cipher_map[i].cipher;
    }

    /* XXX add signature algorithms */
    /* XXX add key encipherment algorithms */

    smime_capabilities[capIndex] = NULL;  /* last one - now encode */
    dummy = SEC_ASN1EncodeItem(poolp, dest, &smime_capabilities, NSSSMIMECapabilitiesTemplate);

    /* now that we have the proper encoded SMIMECapabilities (or not),
     * free the work data */
    for (i = 0; smime_capabilities[i] != NULL; i++)
       PORT_Free(smime_capabilities[i]);
    PORT_Free(smime_capabilities);

    return (dummy == NULL) ? SECFailure : SECSuccess;
}
SECStatus NSS_SMIMEUtil_CreateSMIMEEncKeyPrefs ( PLArenaPool poolp,
SECItem *  dest,
CERTCertificate *  cert 
)

Definition at line 664 of file smimeutil.c.

{
    NSSSMIMEEncryptionKeyPreference ekp;
    SECItem *dummy = NULL;
    PLArenaPool *tmppoolp = NULL;

    if (cert == NULL)
       goto loser;

    tmppoolp = PORT_NewArena(1024);
    if (tmppoolp == NULL)
       goto loser;

    /* XXX hardcoded IssuerSN choice for now */
    ekp.selector = NSSSMIMEEncryptionKeyPref_IssuerSN;
    ekp.id.issuerAndSN = CERT_GetCertIssuerAndSN(tmppoolp, cert);
    if (ekp.id.issuerAndSN == NULL)
       goto loser;

    dummy = SEC_ASN1EncodeItem(poolp, dest, &ekp, smime_encryptionkeypref_template);

loser:
    if (tmppoolp) PORT_FreeArena(tmppoolp, PR_FALSE);

    return (dummy == NULL) ? SECFailure : SECSuccess;
}
PRBool NSS_SMIMEUtil_DecryptionAllowed ( SECAlgorithmID *  algid,
PK11SymKey *  key 
)

Definition at line 294 of file smimeutil.c.

{
    unsigned long which;

    if (nss_smime_get_cipher_for_alg_and_key(algid, key, &which) != SECSuccess)
       return PR_FALSE;

    return nss_smime_cipher_allowed(which);
}
SECStatus NSS_SMIMEUtil_EnableCipher ( unsigned long  which,
PRBool  on 
)

Definition at line 178 of file smimeutil.c.

{
    unsigned long mask;
    int mapi;

    mask = which & CIPHER_FAMILYID_MASK;

    PORT_Assert (mask == CIPHER_FAMILYID_SMIME);
    if (mask != CIPHER_FAMILYID_SMIME)
       /* XXX set an error! */
       return SECFailure;

    mapi = smime_mapi_by_cipher(which);
    if (mapi < 0)
       /* XXX set an error */
       return SECFailure;

    /* do we try to turn on a forbidden cipher? */
    if (!smime_cipher_map[mapi].allowed && on) {
       PORT_SetError (SEC_ERROR_BAD_EXPORT_ALGORITHM);
       return SECFailure;
    }

    if (smime_cipher_map[mapi].enabled != on)
       smime_cipher_map[mapi].enabled = on;

    return SECSuccess;
}

Here is the call graph for this function:

Definition at line 324 of file smimeutil.c.

{
    int i;

    for (i = 0; i < smime_cipher_map_count; i++) {
       if (smime_cipher_map[i].allowed)
           return PR_TRUE;
    }
    return PR_FALSE;
}
SECStatus NSS_SMIMEUtil_FindBulkAlgForRecipients ( CERTCertificate **  rcerts,
SECOidTag bulkalgtag,
int keysize 
)

Definition at line 561 of file smimeutil.c.

{
    unsigned long cipher;
    int mapi;

    cipher = smime_choose_cipher(NULL, rcerts);
    mapi = smime_mapi_by_cipher(cipher);

    *bulkalgtag = smime_cipher_map[mapi].algtag;
    *keysize = smime_keysize_by_cipher(smime_cipher_map[mapi].cipher);

    return SECSuccess;
}
CERTCertificate* NSS_SMIMEUtil_GetCertFromEncryptionKeyPreference ( CERTCertDBHandle *  certdb,
SECItem *  DERekp 
)

Definition at line 736 of file smimeutil.c.

{
    PLArenaPool *tmppoolp = NULL;
    CERTCertificate *cert = NULL;
    NSSSMIMEEncryptionKeyPreference ekp;

    tmppoolp = PORT_NewArena(1024);
    if (tmppoolp == NULL)
       return NULL;

    /* decode DERekp */
    if (SEC_QuickDERDecodeItem(tmppoolp, &ekp, smime_encryptionkeypref_template,
                               DERekp) != SECSuccess)
       goto loser;

    /* find cert */
    switch (ekp.selector) {
    case NSSSMIMEEncryptionKeyPref_IssuerSN:
       cert = CERT_FindCertByIssuerAndSN(certdb, ekp.id.issuerAndSN);
       break;
    case NSSSMIMEEncryptionKeyPref_RKeyID:
    case NSSSMIMEEncryptionKeyPref_SubjectKeyID:
       /* XXX not supported yet - we need to be able to look up certs by SubjectKeyID */
       break;
    default:
       PORT_Assert(0);
    }
loser:
    if (tmppoolp) PORT_FreeArena(tmppoolp, PR_FALSE);

    return cert;
}
PRBool NSSSMIME_VersionCheck ( const char *  importedVersion)

Definition at line 773 of file smimeutil.c.

{
    /*
     * This is the secret handshake algorithm.
     *
     * This release has a simple version compatibility
     * check algorithm.  This release is not backward
     * compatible with previous major releases.  It is
     * not compatible with future major, minor, or
     * patch releases.
     */
    volatile char c; /* force a reference that won't get optimized away */

    c = __nss_smime_rcsid[0] + __nss_smime_sccsid[0]; 

    return NSS_VersionCheck(importedVersion);
}

Here is the call graph for this function:

static long smime_choose_cipher ( CERTCertificate *  scert,
CERTCertificate **  rcerts 
) [static]

Definition at line 382 of file smimeutil.c.

{
    PRArenaPool *poolp;
    long cipher;
    long chosen_cipher;
    int *cipher_abilities;
    int *cipher_votes;
    int weak_mapi;
    int strong_mapi;
    int rcount, mapi, max, i;
    PRBool scert_is_fortezza = (scert == NULL) ? PR_FALSE : PK11_FortezzaHasKEA(scert);

    chosen_cipher = SMIME_RC2_CBC_40;            /* the default, LCD */
    weak_mapi = smime_mapi_by_cipher(chosen_cipher);

    poolp = PORT_NewArena (1024);         /* XXX what is right value? */
    if (poolp == NULL)
       goto done;

    cipher_abilities = (int *)PORT_ArenaZAlloc(poolp, smime_cipher_map_count * sizeof(int));
    cipher_votes     = (int *)PORT_ArenaZAlloc(poolp, smime_cipher_map_count * sizeof(int));
    if (cipher_votes == NULL || cipher_abilities == NULL)
       goto done;

    /* If the user has the Fortezza preference turned on, make
     *  that the strong cipher. Otherwise, use triple-DES. */
    strong_mapi = smime_mapi_by_cipher (SMIME_DES_EDE3_168);
    if (scert_is_fortezza) {
       mapi = smime_mapi_by_cipher(SMIME_FORTEZZA);
       if (mapi >= 0 && smime_cipher_map[mapi].enabled)
           strong_mapi = mapi;
    }

    /* walk all the recipient's certs */
    for (rcount = 0; rcerts[rcount] != NULL; rcount++) {
       SECItem *profile;
       NSSSMIMECapability **caps;
       int pref;

       /* the first cipher that matches in the user's SMIME profile gets
        * "smime_cipher_map_count" votes; the next one gets "smime_cipher_map_count" - 1
        * and so on. If every cipher matches, the last one gets 1 (one) vote */
       pref = smime_cipher_map_count;

       /* find recipient's SMIME profile */
       profile = CERT_FindSMimeProfile(rcerts[rcount]);

       if (profile != NULL && profile->data != NULL && profile->len > 0) {
           /* we have a profile (still DER-encoded) */
           caps = NULL;
           /* decode it */
           if (SEC_QuickDERDecodeItem(poolp, &caps,
                    NSSSMIMECapabilitiesTemplate, profile) == SECSuccess &&
                  caps != NULL)
           {
              /* walk the SMIME capabilities for this recipient */
              for (i = 0; caps[i] != NULL; i++) {
                  cipher = nss_SMIME_FindCipherForSMIMECap(caps[i]);
                  mapi = smime_mapi_by_cipher(cipher);
                  if (mapi >= 0) {
                     /* found the cipher */
                     cipher_abilities[mapi]++;
                     cipher_votes[mapi] += pref;
                     --pref;
                  }
              }
           }
       } else {
           /* no profile found - so we can only assume that the user can do
            * the mandatory algorithms which is RC2-40 (weak crypto) and 3DES (strong crypto) */
           SECKEYPublicKey *key;
           unsigned int pklen_bits;

           /*
            * if recipient's public key length is > 512, vote for a strong cipher
            * please not that the side effect of this is that if only one recipient
            * has an export-level public key, the strong cipher is disabled.
            *
            * XXX This is probably only good for RSA keys.  What I would
            * really like is a function to just say;  Is the public key in
            * this cert an export-length key?  Then I would not have to
            * know things like the value 512, or the kind of key, or what
            * a subjectPublicKeyInfo is, etc.
            */
           key = CERT_ExtractPublicKey(rcerts[rcount]);
           pklen_bits = 0;
           if (key != NULL) {
              pklen_bits = SECKEY_PublicKeyStrength (key) * 8;
              SECKEY_DestroyPublicKey (key);
           }

           if (pklen_bits > 512) {
              /* cast votes for the strong algorithm */
              cipher_abilities[strong_mapi]++;
              cipher_votes[strong_mapi] += pref;
              pref--;
           } 

           /* always cast (possibly less) votes for the weak algorithm */
           cipher_abilities[weak_mapi]++;
           cipher_votes[weak_mapi] += pref;
       }
       if (profile != NULL)
           SECITEM_FreeItem(profile, PR_TRUE);
    }

    /* find cipher that is agreeable by all recipients and that has the most votes */
    max = 0;
    for (mapi = 0; mapi < smime_cipher_map_count; mapi++) {
       /* if not all of the recipients can do this, forget it */
       if (cipher_abilities[mapi] != rcount)
           continue;
       /* if cipher is not enabled or not allowed by policy, forget it */
       if (!smime_cipher_map[mapi].enabled || !smime_cipher_map[mapi].allowed)
           continue;
       /* if we're not doing fortezza, but the cipher is fortezza, forget it */
       if (!scert_is_fortezza  && (smime_cipher_map[mapi].cipher == SMIME_FORTEZZA))
           continue;
       /* now see if this one has more votes than the last best one */
       if (cipher_votes[mapi] >= max) {
           /* if equal number of votes, prefer the ones further down in the list */
           /* with the expectation that these are higher rated ciphers */
           chosen_cipher = smime_cipher_map[mapi].cipher;
           max = cipher_votes[mapi];
       }
    }
    /* if no common cipher was found, chosen_cipher stays at the default */

done:
    if (poolp != NULL)
       PORT_FreeArena (poolp, PR_FALSE);

    return chosen_cipher;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int smime_keysize_by_cipher ( unsigned long  which) [static]

Definition at line 523 of file smimeutil.c.

{
    int keysize;

    switch (which) {
      case SMIME_RC2_CBC_40:
       keysize = 40;
       break;
      case SMIME_RC2_CBC_64:
       keysize = 64;
       break;
      case SMIME_RC2_CBC_128:
       keysize = 128;
       break;
      case SMIME_DES_CBC_56:
      case SMIME_DES_EDE3_168:
      case SMIME_FORTEZZA:
       /*
        * These are special; since the key size is fixed, we actually
        * want to *avoid* specifying a key size.
        */
       keysize = 0;
       break;
      default:
       keysize = -1;
       break;
    }

    return keysize;
}

Here is the caller graph for this function:

static int smime_mapi_by_cipher ( unsigned long  cipher) [static]

Definition at line 163 of file smimeutil.c.

{
    int i;

    for (i = 0; i < smime_cipher_map_count; i++) {
       if (smime_cipher_map[i].cipher == cipher)
           return i; /* bingo */
    }
    return -1;              /* should not happen if we're consistent, right? */
}

Here is the caller graph for this function:


Variable Documentation

Definition at line 53 of file smimever.c.

Definition at line 55 of file smimever.c.

unsigned char asn1_int128[] = { SEC_ASN1_INTEGER, 0x02, 0x00, 0x80 } [static]

Definition at line 62 of file smimeutil.c.

unsigned char asn1_int40[] = { SEC_ASN1_INTEGER, 0x01, 0x28 } [static]

Definition at line 60 of file smimeutil.c.

unsigned char asn1_int64[] = { SEC_ASN1_INTEGER, 0x01, 0x40 } [static]

Definition at line 61 of file smimeutil.c.

Definition at line 326 of file cmsasn1.c.

Initial value:

Definition at line 90 of file smimeutil.c.

Initial value:

Definition at line 80 of file smimeutil.c.

SECItem param_int128 = { siBuffer, asn1_int128, sizeof(asn1_int128) } [static]

Definition at line 67 of file smimeutil.c.

SECItem param_int40 = { siBuffer, asn1_int40, sizeof(asn1_int40) } [static]

Definition at line 65 of file smimeutil.c.

SECItem param_int64 = { siBuffer, asn1_int64, sizeof(asn1_int64) } [static]

Definition at line 66 of file smimeutil.c.

Definition at line 157 of file smimeutil.c.