summary refs log tree commit diff
path: root/crypto/src/asn1/isismtt/x509/AdmissionSyntax.cs
blob: 424d73c6910808a480b74691420d1d53d44af3d2 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
using System;

using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Utilities;

namespace Org.BouncyCastle.Asn1.IsisMtt.X509
{
    /**
    * Attribute to indicate admissions to certain professions.
    * <p/>
    * <pre>
    *     AdmissionSyntax ::= SEQUENCE
    *     {
    *       admissionAuthority GeneralName OPTIONAL,
    *       contentsOfAdmissions SEQUENCE OF Admissions
    *     }
    * <p/>
    *     Admissions ::= SEQUENCE
    *     {
    *       admissionAuthority [0] EXPLICIT GeneralName OPTIONAL
    *       namingAuthority [1] EXPLICIT NamingAuthority OPTIONAL
    *       professionInfos SEQUENCE OF ProfessionInfo
    *     }
    * <p/>
    *     NamingAuthority ::= SEQUENCE
    *     {
    *       namingAuthorityId OBJECT IDENTIFIER OPTIONAL,
    *       namingAuthorityUrl IA5String OPTIONAL,
    *       namingAuthorityText DirectoryString(SIZE(1..128)) OPTIONAL
    *     }
    * <p/>
    *     ProfessionInfo ::= SEQUENCE
    *     {
    *       namingAuthority [0] EXPLICIT NamingAuthority OPTIONAL,
    *       professionItems SEQUENCE OF DirectoryString (SIZE(1..128)),
    *       professionOIDs SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
    *       registrationNumber PrintableString(SIZE(1..128)) OPTIONAL,
    *       addProfessionInfo OCTET STRING OPTIONAL
    *     }
    * </pre>
    * <p/>
    * <p/>
    * ISIS-MTT PROFILE: The relatively complex structure of AdmissionSyntax
    * supports the following concepts and requirements:
    * <ul>
    * <li> External institutions (e.g. professional associations, chambers, unions,
    * administrative bodies, companies, etc.), which are responsible for granting
    * and verifying professional admissions, are indicated by means of the data
    * field admissionAuthority. An admission authority is indicated by a
    * GeneralName object. Here an X.501 directory name (distinguished name) can be
    * indicated in the field directoryName, a URL address can be indicated in the
    * field uniformResourceIdentifier, and an object identifier can be indicated in
    * the field registeredId.</li>
    * <li> The names of authorities which are responsible for the administration of
    * title registers are indicated in the data field namingAuthority. The name of
    * the authority can be identified by an object identifier in the field
    * namingAuthorityId, by means of a text string in the field
    * namingAuthorityText, by means of a URL address in the field
    * namingAuthorityUrl, or by a combination of them. For example, the text string
    * can contain the name of the authority, the country and the name of the title
    * register. The URL-option refers to a web page which contains lists with
    * officially registered professions (text and possibly OID) as well as
    * further information on these professions. Object identifiers for the
    * component namingAuthorityId are grouped under the OID-branch
    * id-isis-at-namingAuthorities and must be applied for.</li>
    * <li>See http://www.teletrust.de/anwend.asp?Id=30200&amp;Sprache=E_&amp;HomePG=0
    * for an application form and http://www.teletrust.de/links.asp?id=30220,11
    * for an overview of registered naming authorities.</li>
    * <li> By means of the data type ProfessionInfo certain professions,
    * specializations, disciplines, fields of activity, etc. are identified. A
    * profession is represented by one or more text strings, resp. profession OIDs
    * in the fields professionItems and professionOIDs and by a registration number
    * in the field registrationNumber. An indication in text form must always be
    * present, whereas the other indications are optional. The component
    * addProfessionInfo may contain additional applicationspecific information in
    * DER-encoded form.</li>
    * </ul>
    * <p/>
    * By means of different namingAuthority-OIDs or profession OIDs hierarchies of
    * professions, specializations, disciplines, fields of activity, etc. can be
    * expressed. The issuing admission authority should always be indicated (field
    * admissionAuthority), whenever a registration number is presented. Still,
    * information on admissions can be given without indicating an admission or a
    * naming authority by the exclusive use of the component professionItems. In
    * this case the certification authority is responsible for the verification of
    * the admission information.
    * <p/>
    * <p/>
    * <p/>
    * This attribute is single-valued. Still, several admissions can be captured in
    * the sequence structure of the component contentsOfAdmissions of
    * AdmissionSyntax or in the component professionInfos of Admissions. The
    * component admissionAuthority of AdmissionSyntax serves as default value for
    * the component admissionAuthority of Admissions. Within the latter component
    * the default value can be overwritten, in case that another authority is
    * responsible. The component namingAuthority of Admissions serves as a default
    * value for the component namingAuthority of ProfessionInfo. Within the latter
    * component the default value can be overwritten, in case that another naming
    * authority needs to be recorded.
    * <p/>
    * The length of the string objects is limited to 128 characters. It is
    * recommended to indicate a namingAuthorityURL in all issued attribute
    * certificates. If a namingAuthorityURL is indicated, the field professionItems
    * of ProfessionInfo should contain only registered titles. If the field
    * professionOIDs exists, it has to contain the OIDs of the professions listed
    * in professionItems in the same order. In general, the field professionInfos
    * should contain only one entry, unless the admissions that are to be listed
    * are logically connected (e.g. they have been issued under the same admission
    * number).
    *
    * @see Org.BouncyCastle.Asn1.IsisMtt.X509.Admissions
    * @see Org.BouncyCastle.Asn1.IsisMtt.X509.ProfessionInfo
    * @see Org.BouncyCastle.Asn1.IsisMtt.X509.NamingAuthority
    */
    public class AdmissionSyntax
        : Asn1Encodable
    {
        private readonly GeneralName admissionAuthority;
        private readonly Asn1Sequence contentsOfAdmissions;

        public static AdmissionSyntax GetInstance(
            object obj)
        {
            if (obj == null || obj is AdmissionSyntax)
            {
                return (AdmissionSyntax)obj;
            }

            if (obj is Asn1Sequence)
            {
                return new AdmissionSyntax((Asn1Sequence)obj);
            }

            throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
        }

        /**
        * Constructor from Asn1Sequence.
        * <p/>
        * The sequence is of type ProcurationSyntax:
        * <p/>
        * <pre>
        *     AdmissionSyntax ::= SEQUENCE
        *     {
        *       admissionAuthority GeneralName OPTIONAL,
        *       contentsOfAdmissions SEQUENCE OF Admissions
        *     }
        * <p/>
        *     Admissions ::= SEQUENCE
        *     {
        *       admissionAuthority [0] EXPLICIT GeneralName OPTIONAL
        *       namingAuthority [1] EXPLICIT NamingAuthority OPTIONAL
        *       professionInfos SEQUENCE OF ProfessionInfo
        *     }
        * <p/>
        *     NamingAuthority ::= SEQUENCE
        *     {
        *       namingAuthorityId OBJECT IDENTIFIER OPTIONAL,
        *       namingAuthorityUrl IA5String OPTIONAL,
        *       namingAuthorityText DirectoryString(SIZE(1..128)) OPTIONAL
        *     }
        * <p/>
        *     ProfessionInfo ::= SEQUENCE
        *     {
        *       namingAuthority [0] EXPLICIT NamingAuthority OPTIONAL,
        *       professionItems SEQUENCE OF DirectoryString (SIZE(1..128)),
        *       professionOIDs SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
        *       registrationNumber PrintableString(SIZE(1..128)) OPTIONAL,
        *       addProfessionInfo OCTET STRING OPTIONAL
        *     }
        * </pre>
        *
        * @param seq The ASN.1 sequence.
        */
        private AdmissionSyntax(Asn1Sequence seq)
        {
            switch (seq.Count)
            {
            case 1:
                this.contentsOfAdmissions = Asn1Sequence.GetInstance(seq[0]);
                break;
            case 2:
                admissionAuthority = GeneralName.GetInstance(seq[0]);
                contentsOfAdmissions = Asn1Sequence.GetInstance(seq[1]);
                break;
            default:
                throw new ArgumentException("Bad sequence size: " + seq.Count);
            }
        }

        /**
        * Constructor from given details.
        *
        * @param admissionAuthority   The admission authority.
        * @param contentsOfAdmissions The admissions.
        */
        public AdmissionSyntax(
            GeneralName admissionAuthority,
            Asn1Sequence contentsOfAdmissions)
        {
            this.admissionAuthority = admissionAuthority;
            this.contentsOfAdmissions = contentsOfAdmissions;
        }

        /**
        * Produce an object suitable for an Asn1OutputStream.
        * <p/>
        * Returns:
        * <p/>
        * <pre>
        *     AdmissionSyntax ::= SEQUENCE
        *     {
        *       admissionAuthority GeneralName OPTIONAL,
        *       contentsOfAdmissions SEQUENCE OF Admissions
        *     }
        * <p/>
        *     Admissions ::= SEQUENCE
        *     {
        *       admissionAuthority [0] EXPLICIT GeneralName OPTIONAL
        *       namingAuthority [1] EXPLICIT NamingAuthority OPTIONAL
        *       professionInfos SEQUENCE OF ProfessionInfo
        *     }
        * <p/>
        *     NamingAuthority ::= SEQUENCE
        *     {
        *       namingAuthorityId OBJECT IDENTIFIER OPTIONAL,
        *       namingAuthorityUrl IA5String OPTIONAL,
        *       namingAuthorityText DirectoryString(SIZE(1..128)) OPTIONAL
        *     }
        * <p/>
        *     ProfessionInfo ::= SEQUENCE
        *     {
        *       namingAuthority [0] EXPLICIT NamingAuthority OPTIONAL,
        *       professionItems SEQUENCE OF DirectoryString (SIZE(1..128)),
        *       professionOIDs SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
        *       registrationNumber PrintableString(SIZE(1..128)) OPTIONAL,
        *       addProfessionInfo OCTET STRING OPTIONAL
        *     }
        * </pre>
        *
        * @return an Asn1Object
        */
        public override Asn1Object ToAsn1Object()
        {
            Asn1EncodableVector v = new Asn1EncodableVector(2);
            v.AddOptional(admissionAuthority);
            v.Add(contentsOfAdmissions);
            return new DerSequence(v);
        }

        /**
        * @return Returns the admissionAuthority if present, null otherwise.
        */
        public virtual GeneralName AdmissionAuthority
        {
            get { return admissionAuthority; }
        }

        /**
        * @return Returns the contentsOfAdmissions.
        */
        public virtual Admissions[] GetContentsOfAdmissions()
        {
            Admissions[] result = new Admissions[contentsOfAdmissions.Count];

            for (int i = 0; i < contentsOfAdmissions.Count; ++i)
            {
                result[i] = Admissions.GetInstance(contentsOfAdmissions[i]);
            }

            return result;
        }
    }
}