Return to authen.h CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / h / quipu

Annotation of 43BSDReno/contrib/isode-beta/h/quipu/authen.h, revision 1.1.1.1

1.1       root        1: /* authen.h - parameters for strong authentication */
                      2: 
                      3: /*
                      4:  * $Header: /f/osi/h/quipu/RCS/authen.h,v 7.0 89/11/23 21:56:23 mrose Rel $
                      5:  *
                      6:  *
                      7:  *
                      8:  * $Log:       authen.h,v $
                      9:  * Revision 7.0  89/11/23  21:56:23  mrose
                     10:  * Release 6.0
                     11:  * 
                     12:  */
                     13: 
                     14: /*
                     15:  *                               NOTICE
                     16:  *
                     17:  *    Acquisition, use, and distribution of this module and related
                     18:  *    materials are subject to the restrictions of a license agreement.
                     19:  *    Consult the Preface in the User's Manual for the full terms of
                     20:  *    this agreement.
                     21:  *
                     22:  */
                     23: 
                     24: 
                     25: #ifndef QUIPUAUTHEN
                     26: #define QUIPUAUTHEN
                     27: #include "quipu/name.h"
                     28: 
                     29: /* Structures for strong authentication */
                     30: 
                     31: struct alg_id {
                     32:        OID algorithm;
                     33:        PE asn;
                     34:        int p_type;
                     35: #define ALG_PARM_ABSENT  0
                     36: #define ALG_PARM_UNKNOWN 1
                     37: #define ALG_PARM_NUMERIC 2
                     38:        union {
                     39:                int numeric;
                     40:        } un;
                     41: };
                     42: 
                     43: struct random_number {
                     44:        int n_bits;
                     45:        char *value;
                     46: };
                     47: 
                     48: struct key_info {
                     49:        struct alg_id alg;
                     50:        int n_bits;
                     51:        char *value;
                     52: };
                     53: 
                     54: struct validity {
                     55:        char *not_before;
                     56:        char *not_after;
                     57: };
                     58: 
                     59: struct signature {
                     60:        struct alg_id alg;
                     61:        PE encoded;
                     62:        int n_bits;
                     63:        char *encrypted;
                     64: };
                     65:                
                     66: struct certificate {
                     67:        struct alg_id alg;
                     68:        int version;
                     69:        int serial;
                     70:        DN issuer;
                     71:        DN subject;
                     72:        struct validity valid;
                     73:        struct key_info key;
                     74:        struct signature sig;
                     75: };
                     76: 
                     77: 
                     78: struct certificate_list {
                     79:        struct certificate *cert;
                     80:        struct certificate *reverse;
                     81:        struct certificate_list *next;
                     82:        struct certificate_list *superior;
                     83: };
                     84: 
                     85: struct revoked_certificate {
                     86:        struct alg_id alg;
                     87:        DN subject;
                     88:        int serial;
                     89:        char *revocation_date;
                     90:        struct revoked_certificate *next;
                     91: };
                     92: 
                     93: struct revocation_list {
                     94:        struct alg_id alg;
                     95:        DN issuer;
                     96:        char *last_update;
                     97:        char *next_update; /* For RFC 1040 format only */
                     98:        struct revoked_certificate *revoked;
                     99:        struct signature sig;
                    100:        struct signature sig2;
                    101: };
                    102: 
                    103: struct ca_record {
                    104:        struct key_info key;
                    105:        DN name;
                    106:        struct validity valid;
                    107:        /* parameters controlling jurisdiction would go here */
                    108:        struct ca_record *next;
                    109: };
                    110: 
                    111: struct protected_password {
                    112:        char *passwd;
                    113:        int n_octets;
                    114:        char protected;
                    115:        char *time1;
                    116:        char *time2;
                    117:        struct random_number *random1;  
                    118:        struct random_number *random2;
                    119: };
                    120: 
                    121: struct security_policy {
                    122:        OID oid;
                    123:        int p_type;
                    124: #define POLICY_PARM_ABSENT     0
                    125: #define POLICY_PARM_UNKNOWN    1
                    126: #define POLICY_PARM_NUMERIC    2
                    127: #define POLICY_PARM_ACCESS     3
                    128:        union {
                    129:                int numeric;
                    130:        } un;
                    131: };
                    132: 
                    133: #define NULLPOLICY ((struct security_policy *) 0)
                    134: 
                    135: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.