Annotation of win32/sql/oracle/include/oci/nzt.h, revision 1.1
1.1 ! parser 1: /* DISABLE check_long_lines */
! 2:
! 3: /* Copyright (c) Oracle Corporation 1996, 1997, 1998, 1999. All Rights Reserved. */
! 4: /* Copyright (c) Oracle Corporation 1996, 1997, 1998, 1999. All Rights Reserved. */
! 5:
! 6: /*
! 7: * $Header: /var/lib/cvsroot/parser3/parser3/src/sql/oracle/oracle32/include/oci/nzt.h,v 1.1 2001/08/22 14:02:18 parser Exp $
! 8: * $Header: /var/lib/cvsroot/parser3/parser3/src/sql/oracle/oracle32/include/oci/nzt.h,v 1.1 2001/08/22 14:02:18 parser Exp $
! 9: */
! 10:
! 11: /*
! 12: * NAME
! 13: * nzt.h
! 14: *
! 15: * DESCRIPTION
! 16: * Toolkit public declarations.
! 17: *
! 18: * PUBLIC FUNCTIONS
! 19: * nztwOpenWallet - Open a wallet based on a WRL and pwd.
! 20: * nztwCloseWallet - Close a wallet.
! 21: * + nztwCreateWallet - Create a new wallet.
! 22: * + nztwDestroyWallet - Destroy an existing wallet.
! 23: * nztwRetrievePersonaCopy - Retieve a copy of a particular persona.
! 24: * + nzteStorePersona - Store a persona in the wallet.
! 25: * nzteOpenPersona - Open a persona.
! 26: * nzteClosePersona - Close a persona.
! 27: * + nzteRemovePersona - Remove a persona from a wallet.
! 28: * + nzteCreatePersona - Create a persona.
! 29: * nzteDestroyPersona - Destroy a persona.
! 30: * nztiStoreTrustedIdentity - Store an identity with associated trust.
! 31: * nzteRetrieveTrustedIdentCopy - Retrieves a trusted identity from persona
! 32: * + nzteSetProtection - Modify the protection set in a persona.
! 33: * + nzteGetProtection - Get the protection set in a persona
! 34: * nztePriKey - Get the Private Key (X509 Only)
! 35: * nzteMyCert - Get the Certificate (X509 only)
! 36: * nzteX509CreatePersona - Create a persona given an X509 Certificate.
! 37: * + nztiRemoveIdentity - Remove an identity from a persona.
! 38: * nztiCreateIdentity - Create an identity.
! 39: * nztiDuplicateIdentity - Create a complete copy of an identity.
! 40: * nztiAbortIdentity - Discard an unstored identity.
! 41: * nztidGetIdentityDesc - Gets Identity Description from Identity.
! 42: * nztidFreeIdentityDesc - Frees memory for Identity Desc object.
! 43: * nztSign - Generate an attached signature.
! 44: * + nztxSignExpansion - Determine size of signature.
! 45: * nztVerify - Verify an attached signature.
! 46: * nztValidate - Validate an identity.
! 47: * nztsd_SignDetached - Generate a detached signature.
! 48: * + nztxsd_SignDetachedExpansion - Determine size of detached signature.
! 49: * nztved_VerifyDetached - Verify a detached signature.
! 50: * + nztEncrypt - Symmetric key encryption.
! 51: * + nztxEncryptExpansion - Determine the tdu length for encryption.
! 52: * + nztDecrypt - Symmetric key decryption.
! 53: * + nztEnvelope - Sign then encrypt data for recipient(s).
! 54: * + nztDeEnvelope - Reverse nztEnvelope.
! 55: * + nztKeyedHash - Generate keyed hash.
! 56: * + nztxKeyedHashExpansion - Determine size of TDU for keyed hash.
! 57: * nztHash - Generate hash.
! 58: * + nztxHashExpansion - Determine the size of the TDU for a hash.
! 59: * nztSeedRandom - See the random number generator.
! 60: * nztrb_RandomBytes - Generate a series of random bytes.
! 61: * nztrn_RandomNumber - Generate a random number.
! 62: * nztbbInitBlock - Initialize a buffer block.
! 63: * nztbbReuseBlock - Reuse a buffer block.
! 64: * nztbbSizeBlock - Find the size of the buffer block.
! 65: * nztbbGrowBlock - Grow initialized buffer block by 'inc' bytes.
! 66: * nztbbPurgeBlock - Purge the memory used within a buffer block.
! 67: * nztbbSetBlock - Set block to known state.
! 68: * nztkec_PKEncrypt - Encrypt data then encrypt key for recipient.
! 69: * nztkdc_PKDecrypt - Decrypt PKEncrypt'ed data.
! 70: * nztific_FreeIdentityContent - Free the contents of an identity.
! 71: * nztifdn - Create an identity from a distinguished name
! 72: * nztcts_CipherSpecToStr - Converts the Cipher Spec Code To String
! 73: * nztiae_IsAuthEnabled - Checks to see if Authentication is Enabled
! 74: * in the current Cipher Spec.
! 75: * nztiae_IsEncrEnabled - Checks to see if Encryption is Enabled
! 76: * in the current Cipher Spec.
! 77: * nztiae_IsHashEnabled - Checks to see if Hashing is Enabled
! 78: * in the current Cipher Spec.
! 79: *
! 80: * NOTE: the '+' indicates that these functions are UNSUPPORTED at this time.
! 81: *
! 82: * NOTES
! 83: *
! 84: * MODIFIED
! 85: * skanjila 06/25/99 - Remove nztcts_CipherSpecToStr() to NZOS.
! 86: * skanjila 06/23/99 - Change API of nztcts_CipherSpecToStr.
! 87: * lkethana 06/18/99 - rem nztIPrivateAlloc, etc
! 88: * lkethana 06/10/99 - changing size_t to ub4
! 89: * lkethana 06/02/99 - add api for getting auth/encry/hash capability of c
! 90: * arswamin 12/28/98 - add NZT_MAX_MD5.
! 91: * arswamin 12/21/98 - change signature of compareDN
! 92: * qdinh 12/21/98 - change size_t to ub4.
! 93: * inetwork 11/22/98 - Removing NZDEPRECATED definition
! 94: * amthakur 09/14/98 - deprecating and updating the c-structures.
! 95: * arswamin 09/24/98 - adding NZTTWRL_NULL for SSO support.
! 96: * amthakur 07/30/98 - changing the prototype of nztGetCertChain.
! 97: * qdinh 05/01/98 - add NZTTIDENTTYPE_INVALID_TYPE
! 98: * qdinh 04/17/98 - add NZTTWRL_ORACLE.
! 99: * ascott 10/08/97 - implement nztiStoreTrustedIdentity
! 100: * ascott 10/07/97 - add nztiGetIdentityDesc
! 101: * ascott 09/28/97 - clarify prototype comments and error codes
! 102: * ascott 09/05/97 - update identity: create, destroy, duplicate
! 103: * ascott 08/21/97 - add GetCert and GetPriKey
! 104: * ascott 08/07/97 - add other WRL settings
! 105: * asriniva 03/25/97 - Add ANSI prototypes
! 106: * rwessman 03/19/97 - Added prototypes for nztific_FreeIdentityContent()
! 107: * asriniva 03/11/97 - Fix olint errors
! 108: * sdange 02/28/97 - Removed inclusion of nz0decl.h
! 109: * sdange 02/18/97 - Moved nzt specific declarations from nz0decl.h
! 110: * asriniva 01/21/97 - Remove prototypes.
! 111: * asriniva 10/31/96 - Include oratypes.h
! 112: * asriniva 10/15/96 - Declare buffer block helper functions
! 113: * asriniva 10/08/96 - First pass at wallet open/close
! 114: * asriniva 10/04/96 - Add random number seed function
! 115: * asriniva 10/03/96 - Reorder parameters in nztbbSetBlock
! 116: * asriniva 10/03/96 - Keep editing.
! 117: * asriniva 10/03/96 - Continued edits.
! 118: * asriniva 10/02/96 - Continue editing.
! 119: * asriniva 09/26/96 -
! 120: */
! 121:
! 122: /* ENABLE check_long_lines */
! 123:
! 124: #ifndef NZT_ORACLE
! 125: #define NZT_ORACLE
! 126:
! 127: #ifndef ORATYPES
! 128: # include <oratypes.h>
! 129: #endif /* ORATYPES */
! 130:
! 131: #ifndef NZERROR_ORACLE
! 132: # include <nzerror.h> /* NZ error type */
! 133: #endif /* NZERROR_ORACLE */
! 134:
! 135: #define NZT_MAX_SHA1 20
! 136: #define NZT_MAX_MD5 16
! 137:
! 138: /***************************************/
! 139: /* PUBLIC CONSTANTS, MACROS, AND TYPES */
! 140: /***************************************/
! 141:
! 142: /*
! 143: * Wallet Resource Locator Type Strings
! 144: *
! 145: * WRL TYPE PARAMETERS BEHAVIOR
! 146: * ======== ========== =====================================
! 147: * default: <none> Uses directory defined by the parameter
! 148: * SNZD_DEFAULT_FILE_DIRECTORY which in
! 149: * unix is "$HOME/oracle/oss"
! 150: *
! 151: * file: file path example: file:/home/ascott
! 152: *
! 153: * sqlnet: <none> In this case, the directory path will be
! 154: * retrieved from the sqlnet.ora file under
! 155: * the oss.source.my_wallet parameter.
! 156: *
! 157: */
! 158: /* Note that there is no NZT_NULL_WRL. Instead look in snzd.h for DEFAULT_WRP
! 159: * which is used in our new defaulting mechanism. The NZT_DEFAULT_WRL
! 160: * should be deprecated.
! 161: */
! 162: #define NZT_DEFAULT_WRL ((text *)"default:")
! 163: #define NZT_SQLNET_WRL ((text *)"sqlnet:")
! 164: #define NZT_FILE_WRL ((text *)"file:")
! 165: #define NZT_ORACLE_WRL ((text *)"oracle:")
! 166: #define NZT_NO_PASSWORD ((text *)"") /* NEVER USED */
! 167:
! 168: enum nzttwrl
! 169: {
! 170: NZTTWRL_DEFAULT = 1, /* Default, use SNZD_DEFAULT_FILE_DIRECTORY */
! 171: NZTTWRL_SQLNET, /* Use oss.source.my_wallet in sqlnet.ora file */
! 172: NZTTWRL_FILE, /* Find the wallet in this directory */
! 173: NZTTWRL_ORACLE, /* Get the wallet from OSS db */
! 174: NZTTWRL_NULL /* New SSO defaulting mechanism */
! 175: };
! 176: typedef enum nzttwrl nzttwrl;
! 177:
! 178: #ifndef NZ0DECL_ORACLE
! 179: /*
! 180: * With the elimination of nz0decl.h from public, we need this
! 181: * redundant typedef.
! 182: */
! 183: typedef struct nzctx nzctx;
! 184: #endif /* NZ0DECL_ORACLE */
! 185:
! 186: /* Moved from nz0decl.h */
! 187:
! 188: typedef struct nzttIdentity nzttIdentity;
! 189: typedef struct nzttIdentityPrivate nzttIdentityPrivate;
! 190: typedef struct nzttPersona nzttPersona;
! 191: typedef struct nzttPersonaPrivate nzttPersonaPrivate;
! 192: typedef struct nzttWallet nzttWallet;
! 193: typedef struct nzttWalletPrivate nzttWalletPrivate;
! 194: typedef struct nzttWalletObj nzttWalletObj; /* For wallet object */
! 195:
! 196: /*
! 197: * Crypto Engine State
! 198: *
! 199: * Once the crypto engine (CE) has been initialized for a particular
! 200: * cipher, it is either at the initial state, or it is continuing to
! 201: * use the cipher. NZTCES_END is used to change the state back to
! 202: * initialized and flush any remaining output. NZTTCES_RESET can be
! 203: * used to change the state back to initialized and throw away any
! 204: * remaining output.
! 205: */
! 206: enum nzttces
! 207: {
! 208: NZTTCES_CONTINUE = 1, /* Continue processing input */
! 209: NZTTCES_END, /* End processing input */
! 210: NZTTCES_RESET /* Reset processing and skip generating output */
! 211: };
! 212: typedef enum nzttces nzttces;
! 213:
! 214: /*
! 215: * Crypto Engine Functions
! 216: *
! 217: * List of crypto engine categories; used to index into protection
! 218: * vector.
! 219: */
! 220: enum nzttcef
! 221: {
! 222: NZTTCEF_DETACHEDSIGNATURE = 1, /* Signature, detached from content */
! 223: NZTTCEF_SIGNATURE, /* Signature combined with content */
! 224: NZTTCEF_ENVELOPING, /* Signature and encryption with content */
! 225: NZTTCEF_PKENCRYPTION, /* Encryption for one or more recipients */
! 226: NZTTCEF_ENCRYPTION, /* Symmetric encryption */
! 227: NZTTCEF_KEYEDHASH, /* Keyed hash/checkusm */
! 228: NZTTCEF_HASH, /* Hash/checsum */
! 229: NZTTCEF_RANDOM, /* Random byte generation */
! 230:
! 231: NZTTCEF_LAST /* Used for array size */
! 232: };
! 233: typedef enum nzttcef nzttcef;
! 234:
! 235: /*
! 236: * State of the persona.
! 237: */
! 238: enum nzttState
! 239: {
! 240: NZTTSTATE_EMPTY = 0, /* is not in any state(senseless???) */
! 241: NZTTSTATE_REQUESTED, /* cert-request */
! 242: NZTTSTATE_READY, /* certificate */
! 243: NZTTSTATE_INVALID, /* certificate */
! 244: NZTTSTATE_RENEWAL /* renewal-requested */
! 245: };
! 246: typedef enum nzttState nzttState;
! 247:
! 248: /*
! 249: * Cert-version types
! 250: *
! 251: * This is used to quickly look-up the cert-type
! 252: */
! 253: enum nzttVersion
! 254: {
! 255: NZTTVERSION_X509v1 = 1, /* X.509v1 */
! 256: NZTTVERSION_X509v3, /* X.509v3 */
! 257: #ifdef NZDEPRECATED
! 258: NZTTVERSION_SYMMETRIC, /* Symmetric */
! 259: #endif
! 260: NZTTVERSION_INVALID_TYPE /* For Initialization */
! 261: };
! 262: typedef enum nzttVersion nzttVersion;
! 263:
! 264: /*
! 265: * Cipher Types
! 266: *
! 267: * List of all cryptographic algorithms, some of which may not be
! 268: * available.
! 269: */
! 270: enum nzttCipherType
! 271: {
! 272: NZTTCIPHERTYPE_RSA = 1, /* RSA public key */
! 273: NZTTCIPHERTYPE_DES, /* DES */
! 274: NZTTCIPHERTYPE_RC4, /* RC4 */
! 275: NZTTCIPHERTYPE_MD5DES, /* DES encrypted MD5 with salt (PBE) */
! 276: NZTTCIPHERTYPE_MD5RC2, /* RC2 encrypted MD5 with salt (PBE) */
! 277: NZTTCIPHERTYPE_MD5, /* MD5 */
! 278: NZTTCIPHERTYPE_SHA /* SHA */
! 279: };
! 280: typedef enum nzttCipherType nzttCipherType;
! 281:
! 282: /*
! 283: * TDU Formats
! 284: *
! 285: * List of possible toolkit data unit (TDU) formats. Depending on the
! 286: * function and cipher used some may be not be available.
! 287: */
! 288: enum nztttdufmt
! 289: {
! 290: NZTTTDUFMT_PKCS7 = 1, /* PKCS7 format */
! 291: NZTTTDUFMT_RSAPAD, /* RSA padded format */
! 292: NZTTTDUFMT_ORACLEv1, /* Oracle v1 format */
! 293: NZTTTDUFMT_LAST /* Used for array size */
! 294: };
! 295: typedef enum nztttdufmt nztttdufmt;
! 296:
! 297: /*
! 298: * Validate State
! 299: *
! 300: * Possible validation states an identity can be in.
! 301: */
! 302: enum nzttValState
! 303: {
! 304: NZTTVALSTATE_NONE = 1, /* Needs to be validated */
! 305: NZTTVALSTATE_GOOD, /* Validated */
! 306: NZTTVALSTATE_REVOKED /* Failed to validate */
! 307: };
! 308: typedef enum nzttValState nzttValState;
! 309:
! 310: /*
! 311: * Policy Fields <----NEW (09/14/98)
! 312: *
! 313: * Policies enforced
! 314: */
! 315: enum nzttPolicy
! 316: {
! 317: NZTTPOLICY_NONE = 0,
! 318: NZTTPOLICY_RETRY_1, /* number of retries for decryption = 1 */
! 319: NZTTPOLICY_RETRY_2, /* number of retries for decryption = 2 */
! 320: NZTTPOLICY_RETRY_3 /* number of retries for decryption = 3 */
! 321: };
! 322: typedef enum nzttPolicy nzttPolicy;
! 323:
! 324: /*
! 325: * Persona Usage <----NEW (09/14/98)
! 326: *
! 327: * what a persona will be used for?
! 328: */
! 329: enum nzttUsage
! 330: {
! 331: NZTTUSAGE_NONE = 0,
! 332: NZTTUSAGE_SSL /* persona for SSL usage */
! 333: };
! 334: typedef enum nzttUsage nzttUsage;
! 335:
! 336: /*
! 337: * Personas and identities have unique id's that are represented with
! 338: * 128 bits.
! 339: */
! 340: typedef ub1 nzttID[16];
! 341:
! 342: /*
! 343: * Identity Types
! 344: *
! 345: * List of all Identity types..
! 346: */
! 347: enum nzttIdentType
! 348: {
! 349: NZTTIDENTITYTYPE_INVALID_TYPE = 0,
! 350: NZTTIDENTITYTYPE_CERTIFICTAE,
! 351: NZTTIDENTITYTYPE_CERT_REQ,
! 352: NZTTIDENTITYTYPE_RENEW_CERT_REQ,
! 353: NZTTIDENTITYTYPE_CLEAR_ETP,
! 354: NZTTIDENTITYTYPE_CLEAR_UTP,
! 355: NZTTIDENTITYTYPE_CLEAR_PTP
! 356: };
! 357: typedef enum nzttIdentType nzttIdentType;
! 358:
! 359: /*
! 360: * Timestamp as 32 bit quantity in UTC.
! 361: */
! 362: typedef ub1 nzttTStamp[4];
! 363:
! 364: /*
! 365: * Buffer Block
! 366: *
! 367: * A function that needs to fill (and possibly grow) an output buffer
! 368: * uses an output parameter block to describe each buffer.
! 369: *
! 370: * The flags_nzttBufferBlock member tells the function whether the
! 371: * buffer can be grown or not. If flags_nzttBufferBlock is 0, then
! 372: * the buffer will be realloc'ed automatically.
! 373: *
! 374: * The buflen_nzttBufferBLock member is set to the length of the
! 375: * buffer before the function is called and will be the length of the
! 376: * buffer when the function is finished. If buflen_nzttBufferBlock is
! 377: * 0, then the initial pointer stored in pobj_nzttBufferBlock is
! 378: * ignored.
! 379: *
! 380: * The objlen_nzttBufferBlock member is set to the length of the
! 381: * object stored in the buffer when the function is finished. If the
! 382: * initial buffer had a non-0 length, then it is possible that the
! 383: * object length is shorter than the buffer length.
! 384: *
! 385: * The pobj_nzttBufferBlock member is a pointer to the output object.
! 386: */
! 387: struct nzttBufferBlock
! 388: {
! 389: # define NZT_NO_AUTO_REALLOC 0x1
! 390:
! 391: uword flags_nzttBufferBlock; /* Flags */
! 392: ub4 buflen_nzttBufferBlock; /* Total length of buffer */
! 393: ub4 usedlen_nzttBufferBlock; /* Length of used buffer part */
! 394: ub1 *buffer_nzttBufferBlock; /* Pointer to buffer */
! 395: };
! 396: typedef struct nzttBufferBlock nzttBufferBlock;
! 397:
! 398: /*
! 399: * Wallet.
! 400: */
! 401: struct nzttWallet
! 402: {
! 403: ub1 *ldapName_nzttWallet; /* user's LDAP Name */
! 404: ub4 ldapNamelen_nzttWallet; /* len of user's LDAP Name */
! 405: nzttPolicy securePolicy_nzttWallet; /* secured-policy of the wallet */
! 406: nzttPolicy openPolicy_nzttWallet; /* open-policy of the wallet */
! 407: nzttPersona *persona_nzttWallet; /* List of personas in wallet */
! 408: nzttWalletPrivate *private_nzttWallet; /* Private wallet information */
! 409: #ifdef NZDEPRECATED
! 410: ub4 npersona_nzttWallet; /* Number of personas */
! 411: #endif
! 412: };
! 413:
! 414: /*
! 415: * The wallet contains, one or more personas. A persona always
! 416: * contains its private key and its identity. It may also contain
! 417: * other 3rd party identites. All identities qualified with trust
! 418: * where the qualifier can indicate anything from untrusted to trusted
! 419: * for specific operations.
! 420: */
! 421:
! 422: /*
! 423: * Persona
! 424: *
! 425: * Structure containing information about a persona.
! 426: */
! 427: struct nzttPersona
! 428: {
! 429: ub1 *genericName_nzttPersona; /* user-friendly persona name */
! 430: ub4 genericNamelen_nzttPersona; /* persona-name length */
! 431: nzttUsage usage_nzttPersona; /* persona usage; SSL/SET/.. */
! 432: nzttState state_nzttPersona; /* persona state-requested/ready */
! 433: nzttPersonaPrivate *private_nzttPersona; /* Opaque part of persona */
! 434: nzttIdentity *mycertreqs_nzttPersona; /* My cert-requests */
! 435: nzttIdentity *mycerts_nzttPersona; /* My certificates */
! 436: nzttIdentity *mytps_nzttPersona; /* List of trusted identities */
! 437: struct nzttPersona *next_nzttPersona; /* Next persona */
! 438: #ifdef NZDEPRECATED
! 439: ub4 ntps_nzttPersona; /* Num of trusted identities */
! 440: #endif
! 441: };
! 442:
! 443: /*
! 444: * Identity
! 445: *
! 446: * Structure containing information about an identity.
! 447: *
! 448: * NOTE
! 449: * -- the next_trustpoint field only applies to trusted identities and
! 450: * has no meaning (i.e. is NULL) for self identities.
! 451: */
! 452: struct nzttIdentity
! 453: {
! 454: text *dn_nzttIdentity; /* Alias */
! 455: ub4 dnlen_nzttIdentity; /* Length of alias */
! 456: text *comment_nzttIdentity; /* Comment */
! 457: ub4 commentlen_nzttIdentity; /* Length of comment */
! 458: nzttIdentityPrivate *private_nzttIdentity; /* Opaque part of identity */
! 459: nzttIdentity *next_nzttIdentity; /* next identity in list */
! 460: };
! 461:
! 462: struct nzttPKCS7ProtInfo
! 463: {
! 464: nzttCipherType mictype_nzttPKCS7ProtInfo; /* Hash cipher */
! 465: nzttCipherType symmtype_nzttPKCS7ProtInfo; /* Symmetric cipher */
! 466: ub4 keylen_nzttPKCS7ProtInfo; /* Length of key to use */
! 467: };
! 468: typedef struct nzttPKCS7ProtInfo nzttPKCS7ProtInfo;
! 469:
! 470: /*
! 471: * Protection Information.
! 472: *
! 473: * Information specific to a type of protection.
! 474: */
! 475: union nzttProtInfo
! 476: {
! 477: nzttPKCS7ProtInfo pkcs7_nzttProtInfo;
! 478: };
! 479: typedef union nzttProtInfo nzttProtInfo;
! 480:
! 481: /*
! 482: * A description of a persona so that the toolkit can create one. A
! 483: * persona can be symmetric or asymmetric and both contain an
! 484: * identity. The identity for an asymmetric persona will be the
! 485: * certificate and the identity for the symmetric persona will be
! 486: * descriptive information about the persona. In either case, an
! 487: * identity will have been created before the persona is created.
! 488: *
! 489: * A persona can be stored separately from the wallet that references
! 490: * it. By default, a persona is stored with the wallet (it inherits
! 491: * with WRL used to open the wallet). If a WRL is specified, then it
! 492: * is used to store the actuall persona and the wallet will have a
! 493: * reference to it.
! 494: */
! 495: struct nzttPersonaDesc
! 496: {
! 497: ub4 privlen_nzttPersonaDesc; /* Length of private info (key)*/
! 498: ub1 *priv_nzttPersonaDesc; /* Private information */
! 499: ub4 prllen_nzttPersonaDesc; /* Length of PRL */
! 500: text *prl_nzttPersonaDesc; /* PRL for storage */
! 501: ub4 aliaslen_nzttPersonaDesc; /* Length of alias */
! 502: text *alias_nzttPersonaDesc; /* Alias */
! 503: ub4 longlen_nzttPersonaDesc; /* Length of longer description*/
! 504: text *long_nzttPersonaDesc; /* Longer persona description */
! 505: };
! 506: typedef struct nzttPersonaDesc nzttPersonaDesc;
! 507:
! 508: /*
! 509: * A description of an identity so that the toolkit can create one.
! 510: * Since an identity can be symmetric or asymmetric, the asymmetric
! 511: * identity information will not be used when a symmetric identity is
! 512: * created. This means the publen_nzttIdentityDesc and
! 513: * pub_nzttIdentityDesc members will not be used when creating a
! 514: * symmetric identity.
! 515: */
! 516: struct nzttIdentityDesc
! 517: {
! 518: ub4 publen_nzttIdentityDesc; /* Length of identity */
! 519: ub1 *pub_nzttIdentityDesc; /* Type specific identity */
! 520: ub4 dnlen_nzttIdentityDesc; /* Length of alias */
! 521: text *dn_nzttIdentityDesc; /* Alias */
! 522: ub4 longlen_nzttIdentityDesc; /* Length of longer description */
! 523: text *long_nzttIdentityDesc; /* Longer description */
! 524: ub4 quallen_nzttIdentityDesc; /* Length of trust qualifier */
! 525: text *trustqual_nzttIdentityDesc; /* Trust qualifier */
! 526: };
! 527: typedef struct nzttIdentityDesc nzttIdentityDesc;
! 528:
! 529: /********************************/
! 530: /* PUBLIC FUNCTION DECLARATIONS */
! 531: /********************************/
! 532:
! 533: /*---------------------- nztwOpenWallet ----------------------*/
! 534:
! 535: /*
! 536: * NAME
! 537: * nztwOpenWallet - Open a wallet based on a wallet Resource Locator (WRL).
! 538: *
! 539: * PARAMETERS
! 540: * osscntxt {IN} OSS context.
! 541: * wrllen {IN} Length of WRL.
! 542: * wrl {IN} WRL.
! 543: * pwdlen {IN} Length of password.
! 544: * pwd {IN} Password.
! 545: * wallet {IN/OUT} Initialized wallet structure.
! 546: *
! 547: * NOTES
! 548: * The syntax for a WRL is <Wallet Type>:<Wallet Type Parameters>.
! 549: *
! 550: * Wallet Type Wallet Type Parameters.
! 551: * ----------- ----------------------
! 552: * File Pathname (e.g. "file:/home/asriniva")
! 553: * Oracle Connect string (e.g. "oracle:scott/tiger@oss")
! 554: *
! 555: * There are also defaults. If the WRL is NZT_DEFAULT_WRL, then
! 556: * the platform specific WRL default is used. If only the wallet
! 557: * type is specified, then the WRL type specific default is used
! 558: * (e.g. "oracle:")
! 559: *
! 560: * There is an implication with Oracle that should be stated: An
! 561: * Oracle based wallet can be implemented in a user's private space
! 562: * or in world readable space.
! 563: *
! 564: * When the wallet is opened, the password is verified by hashing
! 565: * it and comparing against the password hash stored with the
! 566: * wallet. The list of personas (and their associated identities)
! 567: * is built and stored into the wallet structure.
! 568: *
! 569: * RETURNS
! 570: * NZERROR_OK Success.
! 571: * NZERROR_RIO_OPEN RIO could not open wallet (see network trace file).
! 572: * NZERROR_TK_PASSWORD Password verification failed.
! 573: * NZERROR_TK_WRLTYPE WRL type is not known.
! 574: * NZERROR_TK_WRLPARM WRL parm does not match type.
! 575: */
! 576: #ifdef __STDC__
! 577: nzerror nztwOpenWallet(nzctx *, ub4, text *, ub4, text *,
! 578: nzttWallet *);
! 579: #else
! 580: nzerror nztwOpenWallet(/*_ nzctx *, ub4, text *, ub4, text *,
! 581: nzttWallet * _*/);
! 582: #endif /* __STDC __*/
! 583:
! 584: /*---------------------- nztwCloseWallet ----------------------*/
! 585:
! 586: /*
! 587: * NAME
! 588: * nztwCloseWallet - Close a wallet
! 589: *
! 590: * PARAMETERS
! 591: * osscntxt {IN} OSS context.
! 592: * wallet {IN/OUT} Wallet.
! 593: *
! 594: * NOTES
! 595: * Closing a wallet also closes all personas associated with that
! 596: * wallet. It does not cause a persona to automatically be saved
! 597: * if it has changed. The implication is that a persona can be
! 598: * modified by an application but if it is not explicitly saved it
! 599: * reverts back to what was in the wallet.
! 600: *
! 601: * RETURNS
! 602: * NZERROR_OK Success.
! 603: * NZERROR_RIO_CLOSE RIO could not close wallet (see network trace file).
! 604: */
! 605: #ifdef __STDC__
! 606: nzerror nztwCloseWallet(nzctx *, nzttWallet *);
! 607: #else
! 608: nzerror nztwCloseWallet(/*_ nzctx *, nzttWallet * _*/);
! 609: #endif /* __STDC__ */
! 610:
! 611: /*------------------------ nztwConstructWallet -----------------------*/
! 612: /*
! 613: *
! 614: * nzerror nztwConstructWallet( nzctx *oss_context,
! 615: * nzttPolicy openPolicy,
! 616: * nzttPolicy securePolicy,
! 617: * ub1 *ldapName,
! 618: * ub4 ldapNamelen,
! 619: * nzstrc *wrl,
! 620: * nzttPersona *personas,
! 621: * nzttWallet **wallet );
! 622: */
! 623:
! 624: /*---------------------- nztwRetrievePersonaCopy ----------------------*/
! 625:
! 626: /*
! 627: * NAME
! 628: * nztwRetrievePersonaCopy - Retrieves a persona based from wallet
! 629: *
! 630: * PARAMETERS
! 631: * osscntxt {IN} OSS context.
! 632: * wallet {IN} Wallet.
! 633: * index {IN} Which wallet index to remove (first persona is zero).
! 634: * persona {OUT} Persona found.
! 635: *
! 636: * NOTES
! 637: * Retrieves a persona from the wallet based on the index number passed
! 638: * in. This persona is a COPY of the one stored in the wallet, therefore
! 639: * it is perfectly fine for the wallet to be closed after this call is
! 640: * made.
! 641: *
! 642: * The caller is responsible for disposing of the persona when completed.
! 643: *
! 644: * RETURNS
! 645: * NZERROR_OK Success.
! 646: */
! 647: #ifdef __STDC__
! 648: nzerror nztwRetrievePersonaCopy(nzctx *, nzttWallet *, ub4, nzttPersona **);
! 649: #else
! 650: nzerror nztwRetrievePersonaCopy(/*_ nzctx *, nzttWallet *, ub4,
! 651: nzttPersona ** _*/);
! 652: #endif /* __STDC __*/
! 653:
! 654:
! 655: /*---------------------- nzteOpenPersona ----------------------*/
! 656:
! 657: /*
! 658: * NAME
! 659: * nzteOpenPersona - Open a persona.
! 660: *
! 661: * PARAMETERS
! 662: * osscntxt {IN} OSS context.
! 663: * persona {IN/OUT} Persona.
! 664: *
! 665: * NOTES
! 666: *
! 667: * RETURNS
! 668: * NZERROR_OK Success.
! 669: * NZERROR_TK_PASSWORD Password failed to decrypt persona.
! 670: * NZERROR_TK_BADPRL Persona resource locator did not work.
! 671: * NZERROR_RIO_OPEN Could not open persona (see network trace file).
! 672: */
! 673: #ifdef __STDC__
! 674: nzerror nzteOpenPersona(nzctx *, nzttPersona *);
! 675: #else
! 676: nzerror nzteOpenPersona(/*_ nzctx *, nzttPersona * _*/);
! 677: #endif /* __STDC __*/
! 678:
! 679: /*--------------------- nzteClosePersona ---------------------*/
! 680:
! 681: /*
! 682: * NAME
! 683: * nzteClosePersona - Close a persona.
! 684: *
! 685: * PARAMETERS
! 686: * osscntxt {IN} OSS context.
! 687: * persona {IN/OUT} Persona.
! 688: *
! 689: * NOTES
! 690: * Closing a persona does not store the persona, it simply releases
! 691: * the memory associated with the crypto engine.
! 692: *
! 693: * RETURNS
! 694: * NZERROR_OK Success.
! 695: */
! 696: #ifdef __STDC__
! 697: nzerror nzteClosePersona(nzctx *, nzttPersona *);
! 698: #else
! 699: nzerror nzteClosePersona(/*_ nzctx *, nzttPersona * _*/);
! 700: #endif /* __STDC __*/
! 701:
! 702: /*--------------------- nzteDestroyPersona ---------------------*/
! 703:
! 704: /*
! 705: * NAME
! 706: * nzteDestroyPersona - Destroy a persona.
! 707: *
! 708: * PARAMETERS
! 709: * osscntxt {IN} OSS context.
! 710: * persona {IN/OUT} Persona.
! 711: *
! 712: * NOTES
! 713: * The persona is destroyd in the open state, but it will
! 714: * not be associated with a wallet.
! 715: *
! 716: * The persona parameter is doubly indirect so that at the
! 717: * conclusion of the function, the pointer can be set to NULL.
! 718: *
! 719: *
! 720: * RETURNS
! 721: * NZERROR_OK Success.
! 722: * NZERROR_TK_TYPE Unsupported itype/ctype combination.
! 723: * NZERROR_TK_PARMS Error in persona description.
! 724: */
! 725: #ifdef __STDC__
! 726: nzerror nzteDestroyPersona(nzctx *, nzttPersona **);
! 727: #else
! 728: nzerror nzteDestroyPersona(/*_ nzctx *, nzttPersona ** _*/);
! 729: #endif /* __STDC __*/
! 730:
! 731: /*---------------------- nzteRetrieveTrustedIdentCopy ----------------------*/
! 732:
! 733: /*
! 734: * NAME
! 735: * nzteRetrieveTrustedIdentCopy - Retrieves a trusted identity from persona
! 736: *
! 737: * PARAMETERS
! 738: * osscntxt {IN} OSS context.
! 739: * persona {IN} Persona.
! 740: * index {IN} Which wallet index to remove (first element is zero).
! 741: * identity {OUT} Trusted Identity from this persona.
! 742: *
! 743: * NOTES
! 744: * Retrieves a trusted identity from the persona based on the index
! 745: * number passed in. This identity is a COPY of the one stored in
! 746: * the persona, therefore it is perfectly fine to close the persona
! 747: * after this call is made.
! 748: *
! 749: * The caller is responsible for freeing the memory of this object
! 750: * by calling nztiAbortIdentity it is no longer needed
! 751: *
! 752: * RETURNS
! 753: * NZERROR_OK Success.
! 754: */
! 755: #ifdef __STDC__
! 756: nzerror nzteRetrieveTrustedIdentCopy(nzctx *, nzttPersona *, ub4,
! 757: nzttIdentity **);
! 758: #else
! 759: nzerror nzteRetrieveTrustedIdentCopy(/*_ nzctx *, nzttPersona *, ub4,
! 760: nzttIdentity ** _*/);
! 761: #endif /* __STDC __*/
! 762:
! 763: /*--------------------- nztePriKey ---------------------*/
! 764:
! 765: /*
! 766: * NAME
! 767: * nztePriKey - Get the decrypted Private Key for the Persona
! 768: *
! 769: * PARAMETERS
! 770: * osscntxt {IN} OSS context.
! 771: * persona {IN} Persona.
! 772: * vkey {OUT} Private Key [B_KEY_OBJ]
! 773: * vkey_len {OUT} Private Key Length
! 774: *
! 775: * NOTES
! 776: * This funiction will only work for X.509 based persona which contain
! 777: * a private key.
! 778: * A copy of the private key is returned to the caller so that they do not
! 779: * have to worry about the key changeing "underneath them".
! 780: * Memory will be allocated for the vkey and therefore, the CALLER
! 781: * will be responsible for freeing this memory.
! 782: *
! 783: * RETURNS
! 784: * NZERROR_OK Success.
! 785: * NZERROR_NO_MEMORY ossctx is null.
! 786: * NZERROR_TK_BADPRL Persona resource locator did not work.
! 787: */
! 788: #ifdef __STDC__
! 789: nzerror nztePriKey(nzctx *, nzttPersona *, ub1 **, ub4 *);
! 790: #else
! 791: nzerror nztePriKey(/*_ nzctx *, nzttPersona *, ub1 **, ub4 * _*/);
! 792: #endif /* __STDC __*/
! 793:
! 794: /*--------------------- nzteMyCert ---------------------*/
! 795:
! 796: /*
! 797: * NAME
! 798: * nzteMyCert - Get the X.509 Certificate for a persona
! 799: *
! 800: * PARAMETERS
! 801: * osscntxt {IN} OSS context.
! 802: * persona {IN} Persona.
! 803: * cert {OUT} X.509 Certificate [BER encoded]
! 804: * cert_len {OUT} Certificate length
! 805: *
! 806: * NOTES
! 807: * This funiction will only work for X.509 based persona which contain
! 808: * a certificate for the self identity.
! 809: * A copy of the certificate is returned to the caller so that they do not
! 810: * have to worry about the certificate changeing "underneath them".
! 811: * Memory will be allocated for the cert and therefore, the CALLER
! 812: * will be responsible for freeing this memory.
! 813: *
! 814: * RETURNS
! 815: * NZERROR_OK Success.
! 816: * NZERROR_NO_MEMORY ossctx is null.
! 817: */
! 818: #ifdef __STDC__
! 819: nzerror nzteMyCert(nzctx *, nzttPersona *, ub1 **, ub4 *);
! 820: #else
! 821: nzerror nzteMyCert(/*_ nzctx *, nzttPersona *, ub1 **, ub4 * _*/);
! 822: #endif /* __STDC __*/
! 823:
! 824: /*--------------------- nzteX509CreatePersona ---------------------*/
! 825:
! 826: /*
! 827: * NAME
! 828: * nzteX509CreatePersona - Given a BER X.509 cert, create a persona
! 829: *
! 830: * PARAMETERS
! 831: * osscntxt {IN} OSS context.
! 832: * cert {IN} X.509 Certificate [BER encoded]
! 833: * cert_len {IN} Certificate length
! 834: * persona {OUT} Persona.
! 835: *
! 836: * NOTES
! 837: * Memory will be allocated for the persona and therefore, the CALLER
! 838: * will be responsible for freeing this memory.
! 839: *
! 840: * RETURNS
! 841: * NZERROR_OK Success.
! 842: * NZERROR_NO_MEMORY ossctx is null.
! 843: */
! 844: #ifdef __STDC__
! 845: nzerror nzteX509CreatePersona(nzctx *, ub1 *, ub4, nzttPersona **);
! 846: #else
! 847: nzerror nzteX509CreatePersona(/*_ nzctx *, ub1 *, ub4, nzttPersona ** _*/);
! 848: #endif /* __STDC __*/
! 849:
! 850: /*-------------------- nztiCreateIdentity --------------------*/
! 851:
! 852: /*
! 853: * NAME
! 854: * nztiCreateIdentity - Create an identity.
! 855: *
! 856: * PARAMETERS
! 857: * osscntxt {IN} OSS context.
! 858: * itype {IN} Identity type.
! 859: * desc {IN} Description of identity.
! 860: * identity {IN/OUT} Identity.
! 861: *
! 862: * NOTES
! 863: * Memory is only allocated for the identity structure. The elements in
! 864: * the description struct are not copied. Rather their pointers are copied
! 865: * into the identity structure. Therefore, the caller should not free
! 866: * the elements referenced by the desc. These elements will be freed
! 867: * when the nztiDestroyIdentity is called.
! 868: *
! 869: * RETURNS
! 870: * NZERROR_OK Success.
! 871: * NZERROR_PARMS Error in description.
! 872: */
! 873: #ifdef __STDC__
! 874: nzerror nztiCreateIdentity(nzctx *, nzttVersion, nzttIdentityDesc *,
! 875: nzttIdentity **);
! 876: #else
! 877: nzerror nztiCreateIdentity(/*_ nzctx *, nzttVersion, nzttIdentityDesc *,
! 878: nzttIdentity ** _*/);
! 879: #endif /* __STDC __*/
! 880:
! 881: #ifdef NZ_OLD_TOOLS
! 882: /*-------------------- nztiDuplicateIdentity --------------------*/
! 883:
! 884: /*
! 885: * NAME
! 886: * nztiDuplicateIdentity - Duplicate an identity.
! 887: *
! 888: * PARAMETERS
! 889: * osscntxt {IN} OSS context.
! 890: * identity {IN} Target Identity.
! 891: * new_identity {IN} New Identity.
! 892: *
! 893: * NOTES
! 894: * Memory for the identity is allocated inside the function, and all
! 895: * internal identity elements as well.
! 896: *
! 897: * RETURNS
! 898: * NZERROR_OK Success.
! 899: * NZERROR_TK_NOTFOUND Identity not found.
! 900: * NZERROR_PARMS Error in description.
! 901: */
! 902: #ifdef __STDC__
! 903: nzerror nztiDuplicateIdentity(nzctx *, nzttIdentity *,
! 904: nzttIdentity **);
! 905: #else
! 906: nzerror nztiDuplicateIdentity(/*_ nzctx *, nzttIdentity *,
! 907: nzttIdentity ** _*/);
! 908: #endif /* __STDC __*/
! 909: #endif /* NZ_OLD_TOOLS */
! 910:
! 911: /*--------------------- nztiAbortIdentity ---------------------*/
! 912:
! 913: /*
! 914: * NAME
! 915: * nztiAbortIdentity - Abort an unassociated identity.
! 916: *
! 917: * PARAMETERS
! 918: * osscntxt {IN} OSS context.
! 919: * identity {IN/OUT} Identity.
! 920: *
! 921: * NOTES
! 922: * It is an error to try to abort an identity that can be
! 923: * referenced through a persona.
! 924: *
! 925: * The identity pointer is set to NULL at the conclusion.
! 926: *
! 927: * RETURNS
! 928: * NZERROR_OK Success.
! 929: * NZERROR_CANTABORT Identity is associated with persona.
! 930: */
! 931: #ifdef __STDC__
! 932: nzerror nztiAbortIdentity(nzctx *, nzttIdentity **);
! 933: #else
! 934: nzerror nztiAbortIdentity(/*_ nzctx *, nzttIdentity ** _*/);
! 935: #endif /* __STDC __*/
! 936:
! 937: #ifdef NZ_OLD_TOOLS
! 938: /*----------------- nztidGetIdentityDesc -----------------*/
! 939:
! 940: /*
! 941: * NAME
! 942: * nztidGetIdentityDesc - Gets an Identity Description from the identity
! 943: *
! 944: * PARAMETERS
! 945: * osscntxt {IN} Success.
! 946: * identity {IN} Identity.
! 947: * description {IN/OUT} Identity Description.
! 948: *
! 949: * NOTES
! 950: * Memory is allocated for the Identity Description. It
! 951: * is the callers responsibility to free this memory by calling
! 952: * nztiFreeIdentityDesc.
! 953: *
! 954: * RETURNS
! 955: * NZERROR_OK Success.
! 956: */
! 957: #ifdef __STDC__
! 958: nzerror nztidGetIdentityDesc(nzctx *, nzttIdentity *,
! 959: nzttIdentityDesc **);
! 960: #else
! 961: nzerror nztidGetIdentityDesc(/*_ nzctx *, nzttIdentity *,
! 962: nzttIdentityDesc ** _*/);
! 963: #endif /* __STDC __*/
! 964:
! 965: /*----------------- nztidFreeIdentityDesc -----------------*/
! 966:
! 967: /*
! 968: * NAME
! 969: * nztidFreeIdentityDesc - Frees memory for Identity Desc object.
! 970: *
! 971: * PARAMETERS
! 972: * osscntxt {IN} oss context.
! 973: * description {IN/OUT} Identity Description.
! 974: *
! 975: * NOTES
! 976: * Memory is freed for all Identity description elements. Pointer is
! 977: * then set to null.
! 978: *
! 979: * RETURNS
! 980: * NZERROR_OK Success.
! 981: */
! 982: #ifdef __STDC__
! 983: nzerror nztidFreeIdentityDesc(nzctx *, nzttIdentityDesc **);
! 984: #else
! 985: nzerror nztidFreeIdentityDesc(/*_ nzctx *, nzttIdentityDesc ** _*/);
! 986: #endif /* __STDC __*/
! 987: #endif /* NZ_OLD_TOOLS */
! 988:
! 989: /*---------------- nztific_FreeIdentityContent ----------------*/
! 990:
! 991: /*
! 992: * NAME
! 993: * nztific_FreeIdentityContent - free the contents of an identity.
! 994: *
! 995: * PARAMETERS
! 996: * osscntxt {IN} OSS context.
! 997: * identity {IN/OUT} freed identity
! 998: *
! 999: * NOTES
! 1000: * Free a created identity.
! 1001: *
! 1002: * RETURNS
! 1003: * NZERROR_OK Success.
! 1004: */
! 1005: /*
! 1006: * Free the identity content.
! 1007: */
! 1008: #ifdef __STDC__
! 1009: nzerror nztific_FreeIdentityContent(nzctx *ossctx,
! 1010: nzttIdentity *identity);
! 1011: #else
! 1012: nzerror nztific_FreeIdentityContent(/*_ nzctx *ossctx,
! 1013: nzttIdentity *identity _*/);
! 1014: #endif /* __STDC __*/
! 1015:
! 1016:
! 1017: /*-------------------------- nztSign --------------------------*/
! 1018:
! 1019: /*
! 1020: * NAME
! 1021: * nztSign - Create an attached signature.
! 1022: *
! 1023: * PARAMETERS
! 1024: * osscntxt {IN} OSS context.
! 1025: * persona {IN} Open persona acting as signer.
! 1026: * state {IN} State of signature.
! 1027: * inlen {IN} Length of this input part.
! 1028: * in {IN} This input part.
! 1029: * tdubuf {IN/OUT} TDU buffer.
! 1030: *
! 1031: * NOTES
! 1032: *
! 1033: * RETURNS
! 1034: * NZERROR_OK Success.
! 1035: * NZERROR_TK_CANTGROW Needed to grow output buffer but could not.
! 1036: * NZERROR_TK_NOTOPEN Persona is not open.
! 1037: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 1038: */
! 1039: #ifdef __STDC__
! 1040: nzerror nztSign(nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 1041: nzttBufferBlock *);
! 1042: #else
! 1043: nzerror nztSign(/*_ nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 1044: nzttBufferBlock * _*/);
! 1045: #endif /* __STDC __*/
! 1046:
! 1047: /*------------------------- nztVerify -------------------------*/
! 1048:
! 1049: /*
! 1050: * NAME
! 1051: * nztVerify - Verify an attached signature.
! 1052: *
! 1053: * PARAMETERS
! 1054: * osscntxt {IN} OSS context.
! 1055: * persona {IN} Persona.
! 1056: * state {IN} State of verification.
! 1057: * intdulen {IN} TDU length.
! 1058: * intdu {IN} TDU.
! 1059: * out {IN/OUT} Extracted message.
! 1060: * verified {OUT} TRUE if signature verified.
! 1061: * validated{OUT} TRUE if signing identity validated.
! 1062: * identity {OUT} Identity of signing party.
! 1063: *
! 1064: * NOTES
! 1065: *
! 1066: * RETURNS
! 1067: * NZERROR_OK Success.
! 1068: * NZERROR_TK_CANTGROW Needed to grow outptu buffer but could not.
! 1069: * NZERROR_TK_NOTOPEN Persona is not open.
! 1070: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 1071: */
! 1072: #ifdef __STDC__
! 1073: nzerror nztVerify(nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 1074: nzttBufferBlock *, boolean *, boolean *,
! 1075: nzttIdentity **);
! 1076: #else
! 1077: nzerror nztVerify(/*_ nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 1078: nzttBufferBlock *, boolean *, boolean *,
! 1079: nzttIdentity ** _*/);
! 1080: #endif /* __STDC __*/
! 1081:
! 1082: /*------------------------ nztValidate ------------------------*/
! 1083:
! 1084: /*
! 1085: * NAME
! 1086: * nztValidate - Validate an identity.
! 1087: *
! 1088: * PARAMETERS
! 1089: * osscntxt {IN} OSS context.
! 1090: * persona {IN} Persona.
! 1091: * identity {IN} Identity.
! 1092: * validated{OUT} TRUE if identity was validated.
! 1093: *
! 1094: * NOTES
! 1095: *
! 1096: * RETURNS
! 1097: * NZERROR_OK Success.
! 1098: * NZERROR_TK_NOTOPEN Persona is not open.
! 1099: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 1100: */
! 1101: #ifdef __STDC__
! 1102: nzerror nztValidate(nzctx *, nzttPersona *, nzttIdentity *, boolean *);
! 1103: #else
! 1104: nzerror nztValidate(/*_ nzctx *, nzttPersona *, nzttIdentity *, boolean * _*/);
! 1105: #endif /* __STDC __*/
! 1106:
! 1107: /*-------------------- nztsd_SignDetached --------------------*/
! 1108:
! 1109: /*
! 1110: * NAME
! 1111: * nztsd_SignDetached - Generate a detached signature.
! 1112: *
! 1113: * PARAMETERS
! 1114: * osscntxt {IN} OSS context.
! 1115: * persona {IN} Persona.
! 1116: * state {IN} State of signature.
! 1117: * inlen {IN} Length of this input part.
! 1118: * in {IN} This input part.
! 1119: * tdubuf {IN/OUT} TDU buffer.
! 1120: *
! 1121: * NOTES
! 1122: *
! 1123: * RETURNS
! 1124: * NZERROR_OK Success.
! 1125: * NZERROR_TK_CANTGROW Needed to grow output buffer but could not.
! 1126: * NZERROR_TK_NOTOPEN Persona is not open.
! 1127: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 1128: */
! 1129: #ifdef __STDC__
! 1130: nzerror nztsd_SignDetached(nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 1131: nzttBufferBlock *);
! 1132: #else
! 1133: nzerror nztsd_SignDetached(/*_ nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 1134: nzttBufferBlock * _*/);
! 1135: #endif /* __STDC __*/
! 1136:
! 1137: /*------------------- nztved_VerifyDetached -------------------*/
! 1138:
! 1139: /*
! 1140: * NAME
! 1141: * nztved_VerifyDetached - Verify a detached signature.
! 1142: *
! 1143: * PARAMETERS
! 1144: * osscntxt {IN} OSS context.
! 1145: * persona {IN} Persona.
! 1146: * state {IN} State of verification.
! 1147: * inlen {IN} Length of data.
! 1148: * in {IN} Data.
! 1149: * intdulen {IN} Input TDU length.
! 1150: * tdu {IN} Input TDU.
! 1151: * verified {OUT} TRUE if signature verified.
! 1152: * validated{OUT} TRUE if signing identity validated.
! 1153: * identity {OUT} Identity of signing party.
! 1154: *
! 1155: * NOTES
! 1156: *
! 1157: * RETURNS
! 1158: * NZERROR_OK Success.
! 1159: * NZERROR_TK_NOTOPEN Persona is not open.
! 1160: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 1161: */
! 1162: #ifdef __STDC__
! 1163: nzerror nztved_VerifyDetached(nzctx *, nzttPersona *, nzttces, ub4,
! 1164: ub1 *, ub4, ub1 *, boolean *, boolean *,
! 1165: nzttIdentity **);
! 1166: #else
! 1167: nzerror nztved_VerifyDetached(/*_ nzctx *, nzttPersona *, nzttces, ub4,
! 1168: ub1 *, ub4, ub1 *, boolean *, boolean *,
! 1169: nzttIdentity ** _*/);
! 1170: #endif /* __STDC __*/
! 1171:
! 1172: /*--------------------- nztkec_PKEncrypt ---------------------*/
! 1173:
! 1174: /*
! 1175: * NAME
! 1176: * nztkec_PKEncrypt - Encrypt data symmetrically, encrypt key asymmetrically
! 1177: *
! 1178: * PARAMETERS
! 1179: * osscntxt {IN} OSS context.
! 1180: * persona {IN} Persona.
! 1181: * nrecipients {IN} Number of recipients for this encryption.
! 1182: * recipients {IN} List of recipients.
! 1183: * state {IN} State of encryption.
! 1184: * inlen {IN} Length of this input part.
! 1185: * in {IN} This input part.
! 1186: * tdubuf {IN/OUT} TDU buffer.
! 1187: *
! 1188: * NOTES
! 1189: * There is a limitation of 1 recipient (nrecipients = 1) at this
! 1190: * time.
! 1191: *
! 1192: * RETURNS
! 1193: * NZERROR_OK Success.
! 1194: * NZERROR_TK_CANTGROW Needed to grow output buffer but could not.
! 1195: * NZERROR_TK_NOTOPEN Persona is not open.
! 1196: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 1197: */
! 1198: #ifdef __STDC__
! 1199: nzerror nztkec_PKEncrypt(nzctx *, nzttPersona *, ub4, nzttIdentity *,
! 1200: nzttces, ub4, ub1 *, nzttBufferBlock *);
! 1201: #else
! 1202: nzerror nztkec_PKEncrypt(/*_ nzctx *, nzttPersona *, ub4, nzttIdentity *,
! 1203: nzttces, ub4, ub1 *, nzttBufferBlock * _*/);
! 1204: #endif /* __STDC __*/
! 1205:
! 1206: /*---------------- nztxkec_PKEncryptExpansion ----------------*/
! 1207:
! 1208: /*
! 1209: * NAME
! 1210: * nztxkec_PKEncryptExpansion - Determine the buffer needed for PKEncrypt
! 1211: *
! 1212: * PARAMETERS
! 1213: * osscntxt {IN} OSS context.
! 1214: * persona {IN} Persona.
! 1215: * nrecipients {IN} Number of recipients.
! 1216: * inlen {IN} Length of input.
! 1217: * tdulen {out} Length of buffer need.
! 1218: *
! 1219: * NOTES
! 1220: *
! 1221: * RETURNS
! 1222: * NZERROR_OK Success.
! 1223: * NZERROR_TK_NOTOPEN Persona is not open.
! 1224: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 1225: */
! 1226: #ifdef __STDC__
! 1227: nzerror nztxkec_PKEncryptExpansion(nzctx *, nzttPersona *, ub4, ub4,
! 1228: ub4 *);
! 1229: #else
! 1230: nzerror nztxkec_PKEncryptExpansion(/*_ nzctx *, nzttPersona *, ub4, ub4,
! 1231: ub4 * _*/);
! 1232: #endif /* __STDC __*/
! 1233:
! 1234: /*--------------------- nztkdc_PKDecrypt ---------------------*/
! 1235:
! 1236: /*
! 1237: * NAME
! 1238: * nztkdc_PKDecrypt - Decrypt a PKEncrypted message.
! 1239: *
! 1240: * PARAMETERS
! 1241: * osscntxt {IN} OSS context.
! 1242: * persona {IN} Persona.
! 1243: * state {IN} State of encryption.
! 1244: * inlen {IN} Length of this input part.
! 1245: * in {IN} This input part.
! 1246: * tdubuf {IN/OUT} TDU buffer.
! 1247: *
! 1248: * NOTES
! 1249: *
! 1250: * RETURNS
! 1251: * NZERROR_OK Success.
! 1252: * NZERROR_TK_CANTGROW Needed to grow output buffer but could not.
! 1253: * NZERROR_TK_NOTOPEN Persona is not open.
! 1254: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 1255: */
! 1256: #ifdef __STDC__
! 1257: nzerror nztkdc_PKDecrypt(nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 1258: nzttBufferBlock *);
! 1259: #else
! 1260: nzerror nztkdc_PKDecrypt(/*_ nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 1261: nzttBufferBlock * _*/);
! 1262: #endif /* __STDC __*/
! 1263:
! 1264: /*-------------------------- nztHash --------------------------*/
! 1265:
! 1266: /*
! 1267: * NAME
! 1268: * nztHash - Generate a hash.
! 1269: *
! 1270: * PARAMETERS
! 1271: * osscntxt {IN} OSS context.
! 1272: * persona {IN} Persona.
! 1273: * state {IN} State of hash.
! 1274: * inlen {IN} Length of this input.
! 1275: * in {IN} This input.
! 1276: * tdu {IN/OUT} Output tdu.
! 1277: *
! 1278: * NOTES
! 1279: *
! 1280: * RETURNS
! 1281: * NZERROR_OK Success.
! 1282: * NZERROR_TK_CANTGROW Needed to grow TDU buffer but could not.
! 1283: * NZERROR_TK_NOTOPEN Persona is not open.
! 1284: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 1285: */
! 1286: #ifdef __STDC__
! 1287: nzerror nztHash(nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 1288: nzttBufferBlock *);
! 1289: #else
! 1290: nzerror nztHash(/*_ nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 1291: nzttBufferBlock * _*/);
! 1292: #endif /* __STDC __*/
! 1293:
! 1294: /*----------------------- nztSeedRandom -----------------------*/
! 1295:
! 1296: /*
! 1297: * NAME
! 1298: * nztSeedRandom - Seed the random function
! 1299: *
! 1300: * PARAMETERS
! 1301: * osscntxt {IN} OSS context.
! 1302: * persona {IN} Persona.
! 1303: * seedlen {IN} Length of seed.
! 1304: * seed {IN} Seed.
! 1305: *
! 1306: * NOTES
! 1307: *
! 1308: * RETURNS
! 1309: * NZERROR_OK Success.
! 1310: * NZERROR_TK_NOTOPEN Persona is not open.
! 1311: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 1312: */
! 1313: #ifdef __STDC__
! 1314: nzerror nztSeedRandom(nzctx *, nzttPersona *, ub4, ub1 *);
! 1315: #else
! 1316: nzerror nztSeedRandom(/*_ nzctx *, nzttPersona *, ub4, ub1 * _*/);
! 1317: #endif /* __STDC __*/
! 1318:
! 1319: /*--------------------- nztrb_RandomBytes ---------------------*/
! 1320:
! 1321: /*
! 1322: * NAME
! 1323: * nztrb_RandomBytes - Generate a buffer random bytes.
! 1324: *
! 1325: * PARAMETERS
! 1326: * osscntxt {IN} OSS context.
! 1327: * persona {IN} Persona.
! 1328: * nbytes {IN} Number of bytes desired.
! 1329: * out {IN/OUT} Buffer block for bytes.
! 1330: *
! 1331: * NOTES
! 1332: *
! 1333: * RETURNS
! 1334: * NZERROR_OK Success.
! 1335: * NZERROR_TK_CANTGROW Needed to grow TDU buffer but could not.
! 1336: * NZERROR_TK_NOTOPEN Persona is not open.
! 1337: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 1338: */
! 1339: #ifdef __STDC__
! 1340: nzerror nztrb_RandomBytes(nzctx *, nzttPersona *, ub4,
! 1341: nzttBufferBlock *);
! 1342: #else
! 1343: nzerror nztrb_RandomBytes(/*_ nzctx *, nzttPersona *, ub4,
! 1344: nzttBufferBlock * _*/);
! 1345: #endif /* __STDC __*/
! 1346:
! 1347: /*-------------------- nztrn_RandomNumber --------------------*/
! 1348:
! 1349: /*
! 1350: * NAME
! 1351: * nztrn_RandomNumber - Generate a random number
! 1352: *
! 1353: * PARAMETERS
! 1354: * osscntxt {IN} OSS context.
! 1355: * persona {IN} Persona.
! 1356: * num {OUT} Number.
! 1357: *
! 1358: * NOTES
! 1359: *
! 1360: * RETURNS
! 1361: * NZERROR_OK Success.
! 1362: * NZERROR_TK_NOTOPEN Persona is not open.
! 1363: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 1364: */
! 1365: #ifdef __STDC__
! 1366: nzerror nztrn_RandomNumber(nzctx *, nzttPersona *, uword *);
! 1367: #else
! 1368: nzerror nztrn_RandomNumber(/*_ nzctx *, nzttPersona *, uword * _*/);
! 1369: #endif /* __STDC __*/
! 1370:
! 1371: /*---------------------- nztbbInitBlock ----------------------*/
! 1372:
! 1373: /*
! 1374: * NAME
! 1375: * nztbbInitBlock - Initialize a buffer block.
! 1376: *
! 1377: * PARAMETERS
! 1378: * osscntxt {IN} OSS context.
! 1379: * block {IN/OUT} Buffer block.
! 1380: *
! 1381: * NOTES
! 1382: * The buffer block is initialized to be empty (all members are set
! 1383: * to 0/NULL). Such a block will be allocated memory as needed.
! 1384: *
! 1385: * RETURNS
! 1386: * NZERROR_OK Success.
! 1387: */
! 1388: #ifdef __STDC__
! 1389: nzerror nztbbInitBlock(nzctx *, nzttBufferBlock *);
! 1390: #else
! 1391: nzerror nztbbInitBlock(/*_ nzctx *, nzttBufferBlock * _*/);
! 1392: #endif /* __STDC __*/
! 1393:
! 1394: /*---------------------- nztbbReuseBlock ----------------------*/
! 1395:
! 1396: /*
! 1397: * NAME
! 1398: * nztbbReuseBlock - Reuse an already initialized and possibly used block.
! 1399: *
! 1400: * PARAMETERS
! 1401: * osscntxt {IN} OSS context.
! 1402: * block {IN/OUT} Buffer block.
! 1403: *
! 1404: * NOTES
! 1405: * This function simply sets the used length member of the buffer
! 1406: * block to 0. If the block already has memory allocated to it,
! 1407: * this will cause it to be reused.
! 1408: *
! 1409: * RETURNS
! 1410: * NZERROR_OK Success.
! 1411: */
! 1412: #ifdef __STDC__
! 1413: nzerror nztbbReuseBlock(nzctx *, nzttBufferBlock *);
! 1414: #else
! 1415: nzerror nztbbReuseBlock(/*_ nzctx *, nzttBufferBlock * _*/);
! 1416: #endif /* __STDC __*/
! 1417:
! 1418: /*---------------------- nztbbSizeBlock ----------------------*/
! 1419:
! 1420: /*
! 1421: * NAME
! 1422: * nztbbSizeBlock - Size an initialized block to a particular size.
! 1423: *
! 1424: * PARAMETERS
! 1425: * osscntxt {IN} OSS context.
! 1426: * len {IN} Minimum number of unused bytes desired.
! 1427: * block {IN/OUT} Buffer block.
! 1428: *
! 1429: * NOTES
! 1430: *
! 1431: * RETURNS
! 1432: * NZERROR_OK Success.
! 1433: */
! 1434: #ifdef __STDC__
! 1435: nzerror nztbbSizeBlock(nzctx *, ub4, nzttBufferBlock *);
! 1436: #else
! 1437: nzerror nztbbSizeBlock(/*_ nzctx *, ub4, nzttBufferBlock * _*/);
! 1438: #endif /* __STDC __*/
! 1439:
! 1440: /*----------------------- nztbbGrowBlock -----------------------*/
! 1441:
! 1442: /*
! 1443: * NAME
! 1444: * nzbbGrowBlock - Increase the size of the buffer block.
! 1445: *
! 1446: * PARAMETERS
! 1447: * osscntxt {IN} OSS context.
! 1448: * inc {IN} Number of bytes to increase.
! 1449: * block {IN/OUT} Buffer block.
! 1450: *
! 1451: * NOTES
! 1452: *
! 1453: * RETURNS
! 1454: * NZERROR_OK Success.
! 1455: */
! 1456: #ifdef __STDC__
! 1457: nzerror nztbbGrowBlock(nzctx *, ub4, nzttBufferBlock *);
! 1458: #else
! 1459: nzerror nztbbGrowBlock(/*_ nzctx *, ub4, nzttBufferBlock * _*/);
! 1460: #endif /* __STDC __*/
! 1461:
! 1462: /*---------------------- nztbbPurgeBlock ----------------------*/
! 1463:
! 1464: /*
! 1465: * NAME
! 1466: * nztbbPurgeBlock - Purge a buffer block of its memory.
! 1467: *
! 1468: * PARAMETERS
! 1469: * osscntxt {IN} OSS context.
! 1470: * block {IN/OUT} Buffer block.
! 1471: *
! 1472: * NOTES
! 1473: * The memory used by the buffer block as the buffer is released.
! 1474: * The buffer block itself is not affected.
! 1475: *
! 1476: * RETURNS
! 1477: * NZERROR_OK Success.
! 1478: */
! 1479: #ifdef __STDC__
! 1480: nzerror nztbbPurgeBlock(nzctx *, nzttBufferBlock *);
! 1481: #else
! 1482: nzerror nztbbPurgeBlock(/*_ nzctx *, nzttBufferBlock * _*/);
! 1483: #endif /* __STDC __*/
! 1484:
! 1485: /*----------------------- nztbbSetBlock -----------------------*/
! 1486:
! 1487: /*
! 1488: * NAME
! 1489: * nztbbSetBlock - Set a buffer block to a known state.
! 1490: *
! 1491: * PARAMETERS
! 1492: * osscntxt {IN} OSS context.
! 1493: * flags {IN} Flags to set.
! 1494: * buflen {IN} Length of buffer.
! 1495: * usedlen {IN} Used length.
! 1496: * buffer {IN} Buffer.
! 1497: * block {IN/OUT} Buffer block
! 1498: *
! 1499: * NOTES
! 1500: * If buflen > 0, objlen == 0, and obj == NULL, then buflen bytes
! 1501: * of memory is allocated and a pointer is stored in the buffer
! 1502: * block.
! 1503: *
! 1504: * The buffer parameter remains unchanged.
! 1505: *
! 1506: * RETURNS
! 1507: * NZERROR_OK Success.
! 1508: */
! 1509: #ifdef __STDC__
! 1510: nzerror nztbbSetBlock(nzctx *, uword, ub4, ub4, ub1 *,
! 1511: nzttBufferBlock *);
! 1512: #else
! 1513: nzerror nztbbSetBlock(/*_ nzctx *, uword, ub4, ub4, ub1 *,
! 1514: nzttBufferBlock * _*/);
! 1515: #endif /* __STDC __*/
! 1516:
! 1517:
! 1518: /*--------------------- nztiGetSecInfo ---------------------*/
! 1519:
! 1520: /*
! 1521: * NAME
! 1522: * nztiGetSecInfo - Get some security information for SSL
! 1523: *
! 1524: * PARAMETERS
! 1525: * Name {IN/OUT} Description
! 1526: * osscntxt {IN} OSS context.
! 1527: * persona {IN} persona
! 1528: * dname {OUT} distinguished name of the certificate
! 1529: * dnamelen {OUT} length of the distinguished name
! 1530: * issuername {OUT} issuer name of the certificate
! 1531: * certhash {OUT} SHA1 hash of the certificate
! 1532: * certhashlen{OUT} length of the hash
! 1533: * NOTES
! 1534: * This function allocate memories for issuername, certhash, and dname.
! 1535: * To deallocate memory for those params, you should call nztdbuf_DestroyBuf.
! 1536: * RETURNS
! 1537: *
! 1538: */
! 1539: #ifdef __STDC__
! 1540: nzerror nztiGetSecInfo(nzctx *, nzttPersona *, text **, ub4 *,
! 1541: text **, ub4 *, ub1 **, ub4 *);
! 1542: #else
! 1543: nzerror nztiGetSecInfo(/*_ nzctx *, nzttPersona *, text **, ub4 *,
! 1544: text **, ub4 *, ub1 **, ub4 * _*/);
! 1545: #endif /* __STDC__ */
! 1546:
! 1547:
! 1548: /*---------------------- nztiGetDName ----------------------*/
! 1549:
! 1550: /*
! 1551: * NAME
! 1552: * nztiGetDName - Get the distinguished name for the given identity
! 1553: *
! 1554: * PARAMETERS
! 1555: * Name {IN/OUT} Description
! 1556: * osscntxt {IN} OSS context.
! 1557: * identity {IN} identity need to get dname from
! 1558: * dn {OUT} distinguished name
! 1559: * dnlen {OUT} length of the dname
! 1560: *
! 1561: * NOTES
! 1562: *
! 1563: * RETURNS
! 1564: *
! 1565: */
! 1566:
! 1567: #ifdef __STDC__
! 1568: nzerror nztiGetDName(nzctx *, nzttIdentity *,
! 1569: text **, ub4 *);
! 1570: #else
! 1571: nzerror nztiGetDName(/*_ nzctx *, nzttIdentity *,
! 1572: text **, ub4 * _*/);
! 1573: #endif /* __STDC__ */
! 1574:
! 1575: /*------------------- nztiGetIssuerName -------------------*/
! 1576:
! 1577: /*
! 1578: * NAME
! 1579: * nztiGetIssuerName - Get IssuerName for the given identity
! 1580: *
! 1581: * PARAMETERS
! 1582: * Name {IN/OUT} Description
! 1583: * osscntxt {IN} OSS context.
! 1584: * identity {IN} identity need to get issuername from
! 1585: * issuername {OUT} issuer's name
! 1586: * issuernamelen {OUT} length of the issuer's name
! 1587: *
! 1588: * NOTES
! 1589: *
! 1590: * RETURNS
! 1591: *
! 1592: */
! 1593: #ifdef __STDC__
! 1594: nzerror nztiGetIssuerName(nzctx *, nzttIdentity *,
! 1595: text **, ub4 *);
! 1596: #else
! 1597: nzerror nztiGetIssuerName(/*_ nzctx *, nzttIdentity *,
! 1598: text **, ub4 * _*/);
! 1599: #endif /* __STDC__ */
! 1600:
! 1601:
! 1602: /*-------------------- nztgch_GetCertHash --------------------*/
! 1603:
! 1604: /*
! 1605: * NAME
! 1606: * nztgch_GetCertHash - Get SHA1 hash for the certificate of the identity
! 1607: *
! 1608: * PARAMETERS
! 1609: * Name {IN/OUT} Description
! 1610: * osscntxt {IN} OSS context.
! 1611: * identity {IN} identity need to get issuername from
! 1612: * certHash {OUT} certHash buffer
! 1613: * hashLen {OUT} length of the certHash
! 1614: *
! 1615: * NOTES
! 1616: * Need to call nztdbuf_DestroyBuf to deallocate memory for certHash.
! 1617: * RETURNS
! 1618: *
! 1619: */
! 1620: #ifdef __STDC__
! 1621: nzerror nztgch_GetCertHash(nzctx *, nzttIdentity *,
! 1622: ub1 **, ub4 *);
! 1623: #else
! 1624: nzerror nztgch_GetCertHash(/*_ nzctx *, nzttIdentity *,
! 1625: ub1 **, ub4 * _*/);
! 1626: #endif /* __STDC__ */
! 1627:
! 1628: /*-------------------- nztdbuf_DestroyBuf --------------------*/
! 1629:
! 1630: /*
! 1631: * NAME
! 1632: * nztdbuf_DestroyBuf - Deallocation funtions for ub1 and text buffer
! 1633: *
! 1634: * PARAMETERS
! 1635: * Name {IN/OUT} Description
! 1636: * osscntxt {IN} OSS context.
! 1637: * buf {IN} Allocated buffer to be destroyed.
! 1638: *
! 1639: * NOTES
! 1640: *
! 1641: * RETURNS
! 1642: *
! 1643: */
! 1644: #ifdef __STDC__
! 1645: nzerror nztdbuf_DestroyBuf( nzctx *, dvoid **);
! 1646: #else
! 1647: nzerror nztdbuf_DestroyBuf(/*_ nzctx *, dvoid ** _*/);
! 1648: #endif /* __STDC__ */
! 1649:
! 1650:
! 1651: /*----------------------- nztGetCertChain -----------------------*/
! 1652:
! 1653: /*
! 1654: * NAME
! 1655: * nztGetCertChain -
! 1656: *
! 1657: * PARAMETERS
! 1658: * Name {IN/OUT} Description
! 1659: * osscntxt {IN} OSS context.
! 1660: *
! 1661: * NOTES
! 1662: *
! 1663: * RETURNS
! 1664: *
! 1665: */
! 1666: #ifdef __STDC__
! 1667: nzerror nztGetCertChain(nzctx *, nzttWallet * );
! 1668: #else
! 1669: nzerror nztGetCertChain(/*_ nzctx *, nzttWallet _*/);
! 1670: #endif /* __STDC__ */
! 1671:
! 1672: /*----------------------- nztCompareDN -----------------------*/
! 1673:
! 1674: /*
! 1675: * NAME
! 1676: * nztCompareDN -
! 1677: *
! 1678: * PARAMETERS
! 1679: * Name {IN/OUT} Description
! 1680: * osscntxt {IN} OSS context.
! 1681: * dn1 {IN} distinguished name 1
! 1682: * dn2 {IN} distinguished name 2
! 1683: *
! 1684: * NOTES
! 1685: *
! 1686: * RETURNS
! 1687: * NZERROR_OK succeeded
! 1688: * others failed
! 1689: *
! 1690: */
! 1691: #ifdef __STDC__
! 1692: nzerror nztCompareDN(nzctx *, ub1 *, ub4, ub1 *, ub4, boolean * );
! 1693: #else
! 1694: nzerror nztCompareDN(/*_ nzctx *, ub1 *,ub4 , ub1 *, ub4, boolean * _*/);
! 1695: #endif/* __STDC__ */
! 1696:
! 1697:
! 1698: #ifdef NZ_OLD_TOOLS
! 1699: /*--------------------- nztIdentityAlloc ---------------------*/
! 1700:
! 1701: /*
! 1702: * NAME
! 1703: * nztIdentityAlloc - Allocate memory for nzttIdentity context
! 1704: *
! 1705: * PARAMETERS
! 1706: * Name {IN/OUT} Description
! 1707: * osscntxt {IN} OSS context.
! 1708: * identity {OUT} nzttIdentity context
! 1709: *
! 1710: * NOTES
! 1711: *
! 1712: * RETURNS
! 1713: * NZERROR_OK succeeded
! 1714: * others failed
! 1715: *
! 1716: */
! 1717: #ifdef __STDC__
! 1718: nzerror nztIdentityAlloc(nzctx *, nzttIdentity **);
! 1719: #else
! 1720: nzerror nztIdentityAlloc(/*_ nzctx *, nzttIdentity ** _*/);
! 1721: #endif/* __STDC__ */
! 1722:
! 1723: /*--------------------- nztIPrivateAlloc ---------------------*/
! 1724:
! 1725: /*
! 1726: * NAME
! 1727: * nztIPrivateAlloc - Allocate memory for nzttIdentityPrivate
! 1728: *
! 1729: * PARAMETERS
! 1730: * Name {IN/OUT} Description
! 1731: *
! 1732: * osscntxt {IN} OSS context.
! 1733: * ipriv {OUT} identityPrivate structure
! 1734: * NOTES
! 1735: *
! 1736: * RETURNS
! 1737: * NZERROR_OK succeeded
! 1738: * others failed
! 1739: *
! 1740: */
! 1741:
! 1742: #ifdef __STDC__
! 1743: nzerror nztIPrivateAlloc( nzctx *, nzttIdentityPrivate **);
! 1744: #else
! 1745: nzerror nztIPrivateAlloc( nzctx *, nzttIdentityPrivate **);
! 1746: #endif /* __STDC__ */
! 1747:
! 1748:
! 1749: /*---------------------- nztIDupContent ----------------------*/
! 1750:
! 1751: /*
! 1752: * NAME
! 1753: * nztIDupContent -
! 1754: *
! 1755: * PARAMETERS
! 1756: * Name {IN/OUT} Description
! 1757: * osscntxt {IN} OSS context.
! 1758: * targetIdentity{OUT} target identity
! 1759: * sourceIdentity {IN} source identity
! 1760: * NOTES
! 1761: *
! 1762: * RETURNS
! 1763: * NZERROR_OK succeeded
! 1764: * others failed
! 1765: *
! 1766: */
! 1767:
! 1768: #ifdef __STDC__
! 1769: nzerror nztIDupContent( nzctx *, nzttIdentity *, nzttIdentity *);
! 1770: #else
! 1771: nzerror nztIDupContent(/*_ nzctx *, nzttIdentity *, nzttIdentity * _*/);
! 1772: #endif
! 1773: /*---------------------- nztIPDuplicate ----------------------*/
! 1774:
! 1775: /*
! 1776: * NAME
! 1777: * nztIPDuplicate -
! 1778: *
! 1779: * PARAMETERS
! 1780: * Name {IN/OUT} Description
! 1781: * osscntxt {IN} OSS context.
! 1782: * target_ipriv {OUT} target identityPrivate
! 1783: * source_ipriv {IN} source identityPrivate
! 1784: *
! 1785: * NOTES
! 1786: *
! 1787: * RETURNS
! 1788: * NZERROR_OK succeeded
! 1789: * others failed
! 1790: *
! 1791: */
! 1792: #ifdef __STDC__
! 1793: nzerror nztIPDuplicate( nzctx *, nzttIdentityPrivate **,
! 1794: nzttIdentityPrivate *);
! 1795: #else
! 1796: nzerror nztIPDuplicate(/*_ nzctx *, nzttIdentityPrivate **,
! 1797: nzttIdentityPrivate * _*/);
! 1798: #endif /* __STDC__ */
! 1799:
! 1800: /*--------------------- nztiDupIdentList ---------------------*/
! 1801:
! 1802: /*
! 1803: * NAME
! 1804: * nztiDupIdentList -
! 1805: *
! 1806: * PARAMETERS
! 1807: * Name {IN/OUT} Description
! 1808: * osscntxt {IN} OSS context.
! 1809: * source_identities {IN} source identity list
! 1810: * numIdent {OUT} number of identity in the list
! 1811: * ppidentity {OUT} Target of identity
! 1812: *
! 1813: * NOTES
! 1814: *
! 1815: * RETURNS
! 1816: * NZERROR_OK succeeded
! 1817: * others failed
! 1818: *
! 1819: */
! 1820: #ifdef __STDC__
! 1821: nzerror nztiDupIdentList( nzctx *, nzttIdentity *, ub4 *, nzttIdentity **);
! 1822: #else
! 1823:
! 1824: nzerror nztiDupIdentList(/*_ nzctx *, nzttIdentity *, ub4 *, nzttIdentity ** _*/);
! 1825: #endif
! 1826:
! 1827: /*--------------------- nztFreeIdentList ---------------------*/
! 1828:
! 1829: /*
! 1830: * NAME
! 1831: * nztFreeIdentList - Free memory for a list of Identities
! 1832: *
! 1833: * PARAMETERS
! 1834: * Name {IN/OUT} Description
! 1835: * osscntxt {IN} OSS context.
! 1836: * identity {IN} identity context
! 1837: *
! 1838: * NOTES
! 1839: *
! 1840: * RETURNS
! 1841: * NZERROR_OK succeeded
! 1842: * others failed
! 1843: *
! 1844: */
! 1845: #ifdef __STDC__
! 1846: nzerror nztFreeIdentList( nzctx *, nzttIdentity **);
! 1847: #else
! 1848: nzerror nztFreeIdentList(/*_ nzctx *, nzttIdentity ** _*/);
! 1849: #endif
! 1850: #endif /* NZ_OLD_TOOLS */
! 1851:
! 1852: /*--------------------- nztCheckVaLidity ---------------------*/
! 1853:
! 1854: /*
! 1855: * NAME
! 1856: * nztCheckVaLidity - Check the validity of certificate
! 1857: *
! 1858: * PARAMETERS
! 1859: * Name {IN/OUT} Description
! 1860: * osscntxt {IN} OSS context.
! 1861: * start_time Start time of the certificate
! 1862: * end_time End time of the certificate
! 1863: *
! 1864: * NOTES
! 1865: *
! 1866: * RETURNS
! 1867: * NZERROR_OK succeeded
! 1868: * others failed
! 1869: *
! 1870: */
! 1871: #ifdef __STDC__
! 1872: nzerror nztCheckValidity( nzctx *, ub4 , ub4 );
! 1873: #else
! 1874: nzerror nztCheckValidity(/*_ nzctx *, ub4 , ub4 _*/);
! 1875: #endif
! 1876:
! 1877: /*--------------------- nztwCreateWallet ---------------------*/
! 1878:
! 1879: /*
! 1880: * NAME
! 1881: * nztwCreateWallet - Create a new wallet.
! 1882: *
! 1883: * PARAMETERS
! 1884: * osscntxt {IN} OSS context.
! 1885: * wrllen {IN} Length of wallet resource locator.
! 1886: * wrl {IN} WRL.
! 1887: * pwdlen {IN} Length of password (see notes below).
! 1888: * pwd {IN} Password.
! 1889: * wallet {IN/OUT} Wallet.
! 1890: *
! 1891: * NOTES
! 1892: * It is an error to try to create a wallet that already exists.
! 1893: * The previously existing wallet must be destroyed first.
! 1894: *
! 1895: * The wallet itself is not encrypted. Rather, all the personas in
! 1896: * the wallet are encrypted under the same password. A hash of the
! 1897: * password is stored in the wallet.
! 1898: *
! 1899: * Upon success, an empty open wallet is stored in the wallet
! 1900: * parameter.
! 1901: *
! 1902: * RETURNS
! 1903: * NZERROR_OK Sucess.
! 1904: * NZERROR_TK_WALLET_EXISTS Wallet already exists.
! 1905: * NZERROR_RIO_OPEN RIO could not create wallet (see trace file).
! 1906: */
! 1907: #ifdef __STDC__
! 1908: nzerror nztwCreateWallet(nzctx *, ub4, text *, ub4, text *,
! 1909: nzttWallet *);
! 1910: #else
! 1911: nzerror nztwCreateWallet(/*_ nzctx *, ub4, text *, ub4, text *,
! 1912: nzttWallet * _*/);
! 1913: #endif /* __STDC__ */
! 1914:
! 1915:
! 1916: /*--------------------- nztwDestroyWallet ---------------------*/
! 1917:
! 1918: /*
! 1919: * NAME
! 1920: * nztwDestroyWallet - Destroy an existing wallet.
! 1921: *
! 1922: * PARAMETERS
! 1923: * osscntxt {IN} OSS context.
! 1924: * wrllen {IN} Length of wallet resource locator.
! 1925: * wrl {IN} WRL.
! 1926: * pwdlen {IN} Length of password.
! 1927: * pwd {IN} Password.
! 1928: * NOTES
! 1929: *
! 1930: * RETURNS
! 1931: * NZERROR_OK Success.
! 1932: * NZERROR_TK_PASSWORD Password verification failed.
! 1933: * NZERROR_RIO_OPEN RIO could not open wallet (see trace file).
! 1934: * NZERROR_RIO_DELETE Delete failed (see trace file).
! 1935: */
! 1936: #ifdef __STDC__
! 1937: nzerror nztwDestroyWallet(nzctx *, ub4, text *, ub4, text *);
! 1938: #else
! 1939: nzerror nztwDestroyWallet(/*_ nzctx *, ub4, text *, ub4, text * _*/);
! 1940: #endif /* __STDC __*/
! 1941:
! 1942: /*--------------------- nzteStorePersona ---------------------*/
! 1943:
! 1944: /*
! 1945: * NAME
! 1946: * nzteStorePersona - Store an open persona in a wallet.
! 1947: *
! 1948: * PARAMETERS
! 1949: * osscntxt {IN} OSS context.
! 1950: * persona {IN/OUT} Persona.
! 1951: * wallet {IN/OUT} Wallet.
! 1952: *
! 1953: * NOTES
! 1954: * If the open persona is not associated with any wallet (it was
! 1955: * created via the nzteClosePersona function), then storing the
! 1956: * persona creates that association. The wallet will also have an
! 1957: * updated persona list that reflects this association.
! 1958: *
! 1959: * If the open persona was associated with wallet 'A' (it was
! 1960: * opened via the nztwOpenWallet function), and is stored back into
! 1961: * wallet 'A', then then the old persona is overwritten by the new
! 1962: * persona if the password can be verified. Recall that all
! 1963: * personas have a unique identity id. If that id changes then
! 1964: * storing the persona will put a new persona in the wallet.
! 1965: *
! 1966: * If the open persona was associated with wallet 'A' and is stored
! 1967: * into wallet 'B', and if wallet 'B' does not contain a persona
! 1968: * with that unique identity id, then the persona will be copied
! 1969: * into wallet 'B', wallet 'B''s persona list will be updated, and
! 1970: * the persona structure will be updated to be associated with
! 1971: * wallet 'B'. If wallet 'B' already contained the persona, it
! 1972: * would be overwritten by the new persona.
! 1973: *
! 1974: * The persona parameter is doubly indirect so that at the
! 1975: * conclusion of the function call, the pointer can be directed to
! 1976: * the persona in the wallet.
! 1977: *
! 1978: * RETURNS
! 1979: * NZERROR_OK Success.
! 1980: * NZERROR_TK_PASSWORD Password verification failed.
! 1981: * NZERROR_RIO_STORE Store failed (see network trace file).
! 1982: */
! 1983: #ifdef __STDC__
! 1984: nzerror nzteStorePersona(nzctx *, nzttPersona **, nzttWallet *);
! 1985: #else
! 1986: nzerror nzteStorePersona(/*_ nzctx *, nzttPersona **, nzttWallet * _*/);
! 1987: #endif /* __STDC __*/
! 1988:
! 1989: /*--------------------- nzteRemovePersona ---------------------*/
! 1990:
! 1991: /*
! 1992: * NAME
! 1993: * nzteRemovePersona - Remove a persona from the wallet.
! 1994: *
! 1995: * PARAMETERS
! 1996: * osscntxt {IN} OSS context.
! 1997: * persona {IN/OUT} Persona.
! 1998: *
! 1999: * NOTES
! 2000: * The password is verified before trying to remove the persona.
! 2001: *
! 2002: * If the persona is open, it is closed. The persona is removed
! 2003: * from the wallet list and the persona pointer is set to NULL.
! 2004: *
! 2005: * A double indirect pointer to the persona is required so that the
! 2006: * persona pointer can be set to NULL upon completion.
! 2007: *
! 2008: * RETURNS
! 2009: * NZERROR_OK Success.
! 2010: * NZERROR_TK_PASSWORD Password verification failed.
! 2011: * NZERROR_RIO_DELETE Delete failed.
! 2012: */
! 2013: #ifdef __STDC__
! 2014: nzerror nzteRemovePersona(nzctx *, nzttPersona **);
! 2015: #else
! 2016: nzerror nzteRemovePersona(/*_ nzctx *, nzttPersona ** _*/);
! 2017: #endif /* __STDC __*/
! 2018:
! 2019: /*--------------------- nzteCreatePersona ---------------------*/
! 2020:
! 2021: /*
! 2022: * NAME
! 2023: * nzteCreatePersona - Create a persona.
! 2024: *
! 2025: * PARAMETERS
! 2026: * osscntxt {IN} OSS context.
! 2027: * itype {IN} Identity type.
! 2028: * ctype {IN} Cipher type.
! 2029: * desc {IN} Persona description.
! 2030: * persona {OUT} Persona.
! 2031: *
! 2032: * NOTES
! 2033: * The resulting persona is created in the open state, but it will
! 2034: * not be associated with a wallet.
! 2035: *
! 2036: * The memory for the persona is allocated by the function.
! 2037: *
! 2038: * RETURNS
! 2039: * NZERROR_OK Success.
! 2040: * NZERROR_TK_TYPE Unsupported itype/ctype combination.
! 2041: * NZERROR_TK_PARMS Error in persona description.
! 2042: */
! 2043: #ifdef __STDC__
! 2044: nzerror nzteCreatePersona(nzctx *, nzttVersion, nzttCipherType,
! 2045: nzttPersonaDesc *, nzttPersona **);
! 2046: #else
! 2047: nzerror nzteCreatePersona(/*_ nzctx *, nzttVersion, nzttCipherType,
! 2048: nzttPersonaDesc *, nzttPersona ** _*/);
! 2049: #endif /* __STDC __*/
! 2050:
! 2051:
! 2052: /*----------------- nztiStoreTrustedIdentity -----------------*/
! 2053:
! 2054: /*
! 2055: * NAME
! 2056: * nztiStoreTrustedIdentity - Store an identity into a persona.
! 2057: *
! 2058: * PARAMETERS
! 2059: * osscntxt {IN} Success.
! 2060: * identity {IN/OUT} Trusted Identity.
! 2061: * persona {IN/OUT} Persona.
! 2062: *
! 2063: * NOTES
! 2064: * The identity is not saved with the persona in the wallet until
! 2065: * the persona is stored.
! 2066: *
! 2067: * The identity parameter is double indirect so that it can point
! 2068: * into the persona at the conclusion of the call.
! 2069: *
! 2070: * RETURNS
! 2071: * NZERROR_OK Success.
! 2072: */
! 2073: #ifdef __STDC__
! 2074: nzerror nztiStoreTrustedIdentity(nzctx *, nzttIdentity **,
! 2075: nzttPersona *);
! 2076: #else
! 2077: nzerror nztiStoreTrustedIdentity(/*_ nzctx *, nzttIdentity **,
! 2078: nzttPersona * _*/);
! 2079: #endif /* __STDC __*/
! 2080:
! 2081: /*--------------------- nzteSetProtection ---------------------*/
! 2082:
! 2083: /*
! 2084: * NAME
! 2085: * nzteSetProtection - Set the protection type for a CE function.
! 2086: *
! 2087: * PARAMETERS
! 2088: * osscntxt {IN} OSS context.
! 2089: * persona {IN/OUT} Persona.
! 2090: * func {IN} CE function.
! 2091: * tdufmt {IN} TDU Format.
! 2092: * protinfo {IN} Protection information specific to this format.
! 2093: *
! 2094: * NOTES
! 2095: *
! 2096: * RETURNS
! 2097: * NZERROR_OK Success.
! 2098: * NZERROR_TK_PROTECTION Unsupported protection.
! 2099: * NZERROR_TK_PARMS Error in protection info.
! 2100: */
! 2101: #ifdef __STDC__
! 2102: nzerror nzteSetProtection(nzctx *, nzttPersona *, nzttcef, nztttdufmt,
! 2103: nzttProtInfo *);
! 2104: #else
! 2105: nzerror nzteSetProtection(/*_ nzctx *, nzttPersona *, nzttcef, nztttdufmt,
! 2106: nzttProtInfo * _*/);
! 2107: #endif /* __STDC __*/
! 2108:
! 2109: /*--------------------- nzteGetProtection ---------------------*/
! 2110:
! 2111: /*
! 2112: * NAME
! 2113: * nzteGetProtection - Get the protection type for a CE function.
! 2114: *
! 2115: * PARAMETERS
! 2116: * osscntxt {IN} OSS context.
! 2117: * persona {IN} Persona.
! 2118: * func {IN} CE function.
! 2119: * tdufmt {OUT} TDU format.
! 2120: * protinfo {OUT} Protection information.
! 2121: *
! 2122: * NOTES
! 2123: *
! 2124: * RETURNS
! 2125: * NZERROR_OK Success.
! 2126: */
! 2127: #ifdef __STDC__
! 2128: nzerror nzteGetProtection(nzctx *, nzttPersona *, nzttcef, nztttdufmt *,
! 2129: nzttProtInfo *);
! 2130: #else
! 2131: nzerror nzteGetProtection(/*_ nzctx *, nzttPersona *, nzttcef, nztttdufmt *,
! 2132: nzttProtInfo * _*/);
! 2133: #endif /* __STDC __*/
! 2134:
! 2135: /*-------------------- nztiRemoveIdentity --------------------*/
! 2136:
! 2137: /*
! 2138: * NAME
! 2139: * nztiRemoveIdentity - Remove an identity from an open persona.
! 2140: *
! 2141: * PARAMETERS
! 2142: * osscntxt {IN} OSS context.
! 2143: * identity {IN/OUT} Identity.
! 2144: *
! 2145: * NOTES
! 2146: * If the persona is not stored, this identity will still be in the
! 2147: * persona stored in the wallet.
! 2148: *
! 2149: * The identity parameter is doubly indirect so that at the
! 2150: * conclusion of the function, the pointer can be set to NULL.
! 2151: *
! 2152: * RETURNS
! 2153: * NZERROR_OK Success.
! 2154: * NZERROR_TK_NOTFOUND Identity not found.
! 2155: * NZERROR_TK_NOTOPEN Persona is not open.
! 2156: */
! 2157: #ifdef __STDC__
! 2158: nzerror nztiRemoveIdentity(nzctx *, nzttIdentity **);
! 2159: #else
! 2160: nzerror nztiRemoveIdentity(/*_ nzctx *, nzttIdentity ** _*/);
! 2161: #endif /* __STDC __*/
! 2162:
! 2163: /*----------------- nztifdn -----------------*/
! 2164:
! 2165: /*
! 2166: * NAME
! 2167: * nztifdn - create an Identity From a Distinguished Name
! 2168: *
! 2169: * PARAMETERS
! 2170: * osscntxt {IN} OSS context.
! 2171: * length {IN} Length of the distinguished name
! 2172: * distinguished_name {IN} distinguished name string
! 2173: * ppidentity {OUT} created identity
! 2174: *
! 2175: * NOTES
! 2176: * Given a distinguished name, return the identity that corresponds to it.
! 2177: *
! 2178: * RETURNS
! 2179: * NZERROR_OK Success.
! 2180: */
! 2181: #ifdef __STDC__
! 2182: nzerror nztifdn(nzctx *ossctx,
! 2183: ub4 length,
! 2184: text *distinguished_name,
! 2185: nzttIdentity **ppidentity);
! 2186: #else
! 2187: nzerror nztifdn(/*_ nzctx *ossctx,
! 2188: ub4 length,
! 2189: text *distinguished_name,
! 2190: nzttIdentity **ppidentity _*/);
! 2191: #endif /* __STDC __*/
! 2192:
! 2193: /*--------------------- nztxSignExpansion ---------------------*/
! 2194:
! 2195: /*
! 2196: * NAME
! 2197: * nztxSignExpansion - Determine the size of the attached signature buffer.
! 2198: *
! 2199: * PARAMETERS
! 2200: * osscntxt {IN} OSS context.
! 2201: * persona {IN} Persona.
! 2202: * inlen {IN} Length of input.
! 2203: * tdulen {OUT} Buffer needed for signature.
! 2204: *
! 2205: * NOTES
! 2206: *
! 2207: * RETURNS
! 2208: * NZERROR_OK Success.
! 2209: * NZERROR_TK_NOTOPEN Persona is not open.
! 2210: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 2211: */
! 2212: #ifdef __STDC__
! 2213: nzerror nztxSignExpansion(nzctx *, nzttPersona *, ub4, ub4 *);
! 2214: #else
! 2215: nzerror nztxSignExpansion(/*_ nzctx *, nzttPersona *, ub4, ub4 * _*/);
! 2216: #endif /* __STDC __*/
! 2217:
! 2218: /*--------------- nztxsd_SignDetachedExpansion ---------------*/
! 2219:
! 2220: /*
! 2221: * NAME
! 2222: * nztxsd_SignDetachedExpansion - Determine the size of buffer needed.
! 2223: *
! 2224: * PARAMETERS
! 2225: * osscntxt {IN} OSS context.
! 2226: * persona {IN} Persona.
! 2227: * inlen {IN} Length of input.
! 2228: * tdulen {OUT} Buffer needed for signature.
! 2229: *
! 2230: * NOTES
! 2231: *
! 2232: * RETURNS
! 2233: * NZERROR_OK Success.
! 2234: * NZERROR_TK_NOTOPEN Persona is not open.
! 2235: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 2236: */
! 2237: #ifdef __STDC__
! 2238: nzerror nztxsd_SignDetachedExpansion(nzctx *, nzttPersona *, ub4,
! 2239: ub4 *);
! 2240: #else
! 2241: nzerror nztxsd_SignDetachedExpansion(/*_ nzctx *, nzttPersona *, ub4,
! 2242: ub4 * _*/);
! 2243: #endif /* __STDC __*/
! 2244:
! 2245: /*------------------------ nztEncrypt ------------------------*/
! 2246:
! 2247: /*
! 2248: * NAME
! 2249: * nztEncrypt - Symmetrically encrypt
! 2250: *
! 2251: * PARAMETERS
! 2252: * osscntxt {IN} OSS context.
! 2253: * persona {IN} Persona.
! 2254: * inlen {IN} Length of this input part.
! 2255: * in {IN} This input part.
! 2256: * tdubuf {IN/OUT} TDU buffer.
! 2257: *
! 2258: * NOTES
! 2259: *
! 2260: * RETURNS
! 2261: * NZERROR_OK Success.
! 2262: * NZERROR_TK_CANTGROW Needed to grow TDU buffer but could not.
! 2263: * NZERROR_TK_NOTOPEN Persona is not open.
! 2264: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 2265: */
! 2266: #ifdef __STDC__
! 2267: nzerror nztEncrypt(nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 2268: nzttBufferBlock *);
! 2269: #else
! 2270: nzerror nztEncrypt(/*_ nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 2271: nzttBufferBlock * _*/);
! 2272: #endif /* __STDC __*/
! 2273:
! 2274: /*------------------- nztxEncryptExpansion -------------------*/
! 2275:
! 2276: /*
! 2277: * NAME
! 2278: * nztxEncryptExpansion - Determine the size of the TDU to encrypt.
! 2279: *
! 2280: * PARAMETERS
! 2281: * osscntxt {IN} OSS context.
! 2282: * persona {IN} Persona.
! 2283: * inlen {IN} Length of this input part.
! 2284: * tdulen {OUT} Length of TDU.
! 2285: *
! 2286: * NOTES
! 2287: *
! 2288: * RETURNS
! 2289: * NZERROR_OK Success.
! 2290: * NZERROR_TK_NOTOPEN Persona is not open.
! 2291: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 2292: */
! 2293: #ifdef __STDC__
! 2294: nzerror nztxEncryptExpansion(nzctx *, nzttPersona *, ub4, ub4 *);
! 2295: #else
! 2296: nzerror nztxEncryptExpansion(/*_ nzctx *, nzttPersona *, ub4, ub4 * _*/);
! 2297: #endif /* __STDC __*/
! 2298:
! 2299: /*------------------------ nztDecrypt ------------------------*/
! 2300:
! 2301: /*
! 2302: * NAME
! 2303: * nztDecrypt - Decrypt an Encrypted message.
! 2304: *
! 2305: * PARAMETERS
! 2306: * osscntxt {IN} OSS context.
! 2307: * persona {IN} Persona.
! 2308: * state {IN} State of decryption.
! 2309: * inlen {IN} Length of this input part.
! 2310: * in {IN} This input part.
! 2311: * out {IN/OUT} Cleartext message.
! 2312: *
! 2313: * NOTES
! 2314: *
! 2315: * RETURNS
! 2316: * NZERROR_OK Success.
! 2317: * NZERROR_TK_CANTGROW Needed to grow TDU buffer but could not.
! 2318: * NZERROR_TK_NOTOPEN Persona is not open.
! 2319: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 2320: */
! 2321: #ifdef __STDC__
! 2322: nzerror nztDecrypt(nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 2323: nzttBufferBlock *);
! 2324: #else
! 2325: nzerror nztDecrypt(/*_ nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 2326: nzttBufferBlock * _*/);
! 2327: #endif /* __STDC __*/
! 2328:
! 2329: /*------------------------ nztEnvelope ------------------------*/
! 2330:
! 2331: /*
! 2332: * NAME
! 2333: * nztEnvelope - Sign and PKEncrypt a message.
! 2334: *
! 2335: * PARAMETERS
! 2336: * osscntxt {IN} OSS context.
! 2337: * persona {IN} Persona.
! 2338: * nrecipients {IN} Number of recipients for this encryption.
! 2339: * recipients {IN} List of recipients.
! 2340: * state {IN} State of encryption.
! 2341: * inlen {IN} Length of this input part.
! 2342: * in {IN} This input part.
! 2343: * tdubuf {IN/OUT} TDU buffer.
! 2344: *
! 2345: * NOTES
! 2346: *
! 2347: * RETURNS
! 2348: * NZERROR_OK Success.
! 2349: * NZERROR_TK_CANTGROW Needed to grow output buffer but could not.
! 2350: * NZERROR_TK_NOTOPEN Persona is not open.
! 2351: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 2352: */
! 2353: #ifdef __STDC__
! 2354: nzerror nztEnvelope(nzctx *, nzttPersona *, ub4, nzttIdentity *,
! 2355: nzttces, ub4, ub1 *, nzttBufferBlock *);
! 2356: #else
! 2357: nzerror nztEnvelope(/*_ nzctx *, nzttPersona *, ub4, nzttIdentity *,
! 2358: nzttces, ub4, ub1 *, nzttBufferBlock * _*/);
! 2359: #endif /* __STDC __*/
! 2360:
! 2361: /*----------------------- nztDeEnvelope -----------------------*/
! 2362:
! 2363: /*
! 2364: * NAME
! 2365: * nztDeEnvelope - PKDecrypt and verify a message.
! 2366: *
! 2367: * PARAMETERS
! 2368: * osscntxt {IN} OSS context.
! 2369: * persona {IN} Persona.
! 2370: * state {IN} State of encryption.
! 2371: * inlen {IN} Length of this input part.
! 2372: * in {IN} This input part.
! 2373: * out {OUT} Message from TDU.
! 2374: * verified {OUT} TRUE if verified.
! 2375: * validated {OUT} TRUE if validated.
! 2376: * sender {OUT} Identity of sender.
! 2377: *
! 2378: * NOTES
! 2379: *
! 2380: * RETURNS
! 2381: * NZERROR_OK Success.
! 2382: * NZERROR_TK_CANTGROW Needed to grow TDU buffer but could not.
! 2383: * NZERROR_TK_NOTOPEN Persona is not open.
! 2384: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 2385: */
! 2386: #ifdef __STDC__
! 2387: nzerror nztDeEnvelope(nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 2388: nzttBufferBlock *, boolean *, boolean *,
! 2389: nzttIdentity **);
! 2390: #else
! 2391: nzerror nztDeEnvelope(/*_ nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 2392: nzttBufferBlock *, boolean *, boolean *,
! 2393: nzttIdentity ** _*/);
! 2394: #endif /* __STDC __*/
! 2395:
! 2396: /*----------------------- nztKeyedHash -----------------------*/
! 2397:
! 2398: /*
! 2399: * NAME
! 2400: * nztKeyedHash - Generate a keyed hash.
! 2401: *
! 2402: * PARAMETERS
! 2403: * osscntxt {IN} OSS context.
! 2404: * persona {IN} Persona.
! 2405: * state {IN} State of hash.
! 2406: * inlen {IN} Length of this input.
! 2407: * in {IN} This input.
! 2408: * tdu {IN/OUT} Output tdu.
! 2409: *
! 2410: * NOTES
! 2411: *
! 2412: * RETURNS
! 2413: * NZERROR_OK Success.
! 2414: * NZERROR_TK_CANTGROW Needed to grow TDU buffer but could not.
! 2415: * NZERROR_TK_NOTOPEN Persona is not open.
! 2416: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 2417: */
! 2418: #ifdef __STDC__
! 2419: nzerror nztKeyedHash(nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 2420: nzttBufferBlock *);
! 2421: #else
! 2422: nzerror nztKeyedHash(/*_ nzctx *, nzttPersona *, nzttces, ub4, ub1 *,
! 2423: nzttBufferBlock * _*/);
! 2424: #endif /* __STDC __*/
! 2425:
! 2426: /*------------------ nztxKeyedHashExpansion ------------------*/
! 2427:
! 2428: /*
! 2429: * NAME
! 2430: * nztxKeyedHashExpansion - Determine the space needed for a keyed hash.
! 2431: *
! 2432: * PARAMETERS
! 2433: * osscntxt {IN} OSS context.
! 2434: * persona {IN} Persona.
! 2435: * inlen {IN} Length of this input.
! 2436: * tdulen {OUT} TDU length.
! 2437: *
! 2438: * NOTES
! 2439: *
! 2440: * RETURNS
! 2441: * NZERROR_OK Success.
! 2442: * NZERROR_TK_NOTOPEN Persona is not open.
! 2443: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 2444: */
! 2445: #ifdef __STDC__
! 2446: nzerror nztxKeyedHashExpansion(nzctx *, nzttPersona *, ub4,
! 2447: ub4 *);
! 2448: #else
! 2449: nzerror nztxKeyedHashExpansion(/*_ nzctx *, nzttPersona *, ub4,
! 2450: ub4 * _*/);
! 2451: #endif /* __STDC __*/
! 2452:
! 2453: /*--------------------- nztxHashExpansion ---------------------*/
! 2454:
! 2455: /*
! 2456: * NAME
! 2457: * nztxHashExpansion - Determine the size of the TDU for a hash.
! 2458: *
! 2459: * PARAMETERS
! 2460: * osscntxt {IN} OSS context.
! 2461: * persona {IN} Persona.
! 2462: * inlen {IN} Length of this input.
! 2463: * tdulen {OUT} TDU length.
! 2464: *
! 2465: * NOTES
! 2466: *
! 2467: * RETURNS
! 2468: * NZERROR_OK Success.
! 2469: * NZERROR_TK_NOTOPEN Persona is not open.
! 2470: * NZERROR_TK_NOTSUPP Function not supported with persona.
! 2471: */
! 2472: #ifdef __STDC__
! 2473: nzerror nztxHashExpansion(nzctx *, nzttPersona *, ub4, ub4 *);
! 2474: #else
! 2475: nzerror nztxHashExpansion(/*_ nzctx *, nzttPersona *, ub4, ub4 * _*/);
! 2476: #endif /* __STDC __*/
! 2477:
! 2478: /*---------------- nztiae_IsAuthEnabled ----------------*/
! 2479:
! 2480: /*
! 2481: * NAME
! 2482: * nztiae_IsAuthEnabled - Checks to see if Authentication is Enabled
! 2483: * in the current Cipher Spec.
! 2484: *
! 2485: * PARAMETERS
! 2486: * ctx {IN} Oracle SSL Context
! 2487: * ncipher {IN} CipherSuite
! 2488: * authEnabled {OUT} Boolean for is Auth Enabled?
! 2489: *
! 2490: * NOTES
! 2491: *
! 2492: * RETURNS
! 2493: * NZERROR_OK on success.
! 2494: * NZERROR_TK_INV_CIPHR_TYPE if Cipher Spec is not Recognized.
! 2495: */
! 2496:
! 2497: #ifdef __STDC__
! 2498: nzerror nztiae_IsAuthEnabled( nzctx *, ub2, boolean *);
! 2499: #else
! 2500: nzerror nztiae_IsAuthEnabled(/*_ nzctx *ctx,
! 2501: ub2 ncipher,
! 2502: boolean *authEnabled _*/);
! 2503: #endif
! 2504:
! 2505: /*---------------- nztiee_IsEncrEnabled ----------------*/
! 2506: /*
! 2507: * NAME
! 2508: * nztiee_IsEncrEnabled - Checks to see if Encryption is Enabled
! 2509: * in the current Cipher Spec.
! 2510: *
! 2511: * PARAMETERS
! 2512: * ctx {IN} Oracle SSL Context
! 2513: * ncipher {IN} CipherSuite
! 2514: * EncrEnabled {OUT} Boolean for is Auth Enabled?
! 2515: *
! 2516: * NOTES
! 2517: *
! 2518: * RETURNS
! 2519: * NZERROR_OK on success.
! 2520: * NZERROR_TK_INV_CIPHR_TYPE if Cipher Spec is not Recognized.
! 2521: */
! 2522:
! 2523: #ifdef __STDC__
! 2524: nzerror nztiee_IsEncrEnabled( nzctx *, ub2, boolean *);
! 2525: #else
! 2526: nzerror nztiee_IsEncrEnabled(/*_ nzctx *ctx,
! 2527: ub2 ncipher,
! 2528: boolean *EncrEnabled _*/);
! 2529: #endif
! 2530: /*---------------- nztihe_IsHashEnabled ----------------*/
! 2531: /*
! 2532: * NAME
! 2533: * nztihe_IsHashEnabled - Checks to see if HAshing is Enabled
! 2534: * in the current Cipher Spec.
! 2535: *
! 2536: * PARAMETERS
! 2537: * ctx {IN} Oracle SSL Context
! 2538: * ncipher {IN} CipherSuite
! 2539: * hashEnabled {OUT} Boolean for is Auth Enabled?
! 2540: *
! 2541: * NOTES
! 2542: *
! 2543: * RETURNS
! 2544: * NZERROR_OK on success.
! 2545: * NZERROR_TK_INV_CIPHR_TYPE if Cipher Spec is not Recognized.
! 2546: */
! 2547:
! 2548: #ifdef __STDC__
! 2549: nzerror nztihe_IsHashEnabled( nzctx *, ub2, boolean *);
! 2550: #else
! 2551: nzerror nztihe_IsHashEnabled(/*_ nzctx *ctx,
! 2552: ub2 ncipher,
! 2553: boolean *hashEnabled _*/);
! 2554: #endif
! 2555: #endif /* NZT_ORACLE */
! 2556:
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nzt.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / win32 / sql / oracle / include / oci