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
|
using System;
using System.Globalization;
using System.IO;
using System.Text;
using Org.BouncyCastle.Utilities;
namespace Org.BouncyCastle.Asn1
{
/// <summary>GeneralizedTime ASN.1 type</summary>
public class Asn1GeneralizedTime
: Asn1Object
{
internal class Meta : Asn1UniversalType
{
internal static readonly Asn1UniversalType Instance = new Meta();
private Meta() : base(typeof(Asn1GeneralizedTime), Asn1Tags.GeneralizedTime) { }
internal override Asn1Object FromImplicitPrimitive(DerOctetString octetString)
{
return CreatePrimitive(octetString.GetOctets());
}
}
public static Asn1GeneralizedTime GetInstance(object obj)
{
if (obj == null)
return null;
if (obj is Asn1GeneralizedTime asn1GeneralizedTime)
return asn1GeneralizedTime;
if (obj is IAsn1Convertible asn1Convertible)
{
Asn1Object asn1Object = asn1Convertible.ToAsn1Object();
if (asn1Object is Asn1GeneralizedTime converted)
return converted;
}
else if (obj is byte[] bytes)
{
try
{
return (Asn1GeneralizedTime)Meta.Instance.FromByteArray(bytes);
}
catch (IOException e)
{
throw new ArgumentException("failed to construct generalized time from byte[]: " + e.Message);
}
}
throw new ArgumentException("illegal object in GetInstance: " + Platform.GetTypeName(obj), nameof(obj));
}
public static Asn1GeneralizedTime GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
{
return (Asn1GeneralizedTime)Meta.Instance.GetContextInstance(taggedObject, declaredExplicit);
}
private readonly string m_timeString;
private readonly bool m_timeStringCanonical;
private readonly DateTime m_dateTime;
public Asn1GeneralizedTime(string timeString)
{
m_timeString = timeString ?? throw new ArgumentNullException(nameof(timeString));
m_timeStringCanonical = false; // TODO Dynamic check?
try
{
m_dateTime = FromString(timeString);
}
catch (FormatException e)
{
throw new ArgumentException("invalid date string: " + e.Message);
}
}
public Asn1GeneralizedTime(DateTime dateTime)
{
dateTime = dateTime.ToUniversalTime();
m_dateTime = dateTime;
m_timeString = ToStringCanonical(dateTime);
m_timeStringCanonical = true;
}
// TODO TimeZoneInfo or other locale-specific constructors?
internal Asn1GeneralizedTime(byte[] contents)
: this(Encoding.ASCII.GetString(contents))
{
}
public string TimeString => m_timeString;
public DateTime ToDateTime()
{
return m_dateTime;
}
internal byte[] GetContents(int encoding)
{
if (encoding == Asn1OutputStream.EncodingDer && !m_timeStringCanonical)
return Encoding.ASCII.GetBytes(ToStringCanonical(m_dateTime));
return Encoding.ASCII.GetBytes(m_timeString);
}
internal override IAsn1Encoding GetEncoding(int encoding)
{
return new PrimitiveEncoding(Asn1Tags.Universal, Asn1Tags.GeneralizedTime, GetContents(encoding));
}
internal override IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo)
{
return new PrimitiveEncoding(tagClass, tagNo, GetContents(encoding));
}
protected override bool Asn1Equals(Asn1Object asn1Object)
{
if (!(asn1Object is Asn1GeneralizedTime that))
return false;
// TODO Performance
return Arrays.AreEqual(
this.GetContents(Asn1OutputStream.EncodingDer),
that.GetContents(Asn1OutputStream.EncodingDer));
}
protected override int Asn1GetHashCode()
{
// TODO Performance
return Arrays.GetHashCode(
this.GetContents(Asn1OutputStream.EncodingDer));
}
internal static Asn1GeneralizedTime CreatePrimitive(byte[] contents)
{
return new Asn1GeneralizedTime(contents);
}
private static DateTime FromString(string s)
{
if (s.Length < 10)
throw new FormatException();
s = s.Replace(',', '.');
if (Platform.EndsWith(s, "Z"))
{
switch (s.Length)
{
case 11: return ParseUtc(s, @"yyyyMMddHH\Z");
case 13: return ParseUtc(s, @"yyyyMMddHHmm\Z");
case 15: return ParseUtc(s, @"yyyyMMddHHmmss\Z");
case 17: return ParseUtc(s, @"yyyyMMddHHmmss.f\Z");
case 18: return ParseUtc(s, @"yyyyMMddHHmmss.ff\Z");
case 19: return ParseUtc(s, @"yyyyMMddHHmmss.fff\Z");
case 20: return ParseUtc(s, @"yyyyMMddHHmmss.ffff\Z");
case 21: return ParseUtc(s, @"yyyyMMddHHmmss.fffff\Z");
case 22: return ParseUtc(s, @"yyyyMMddHHmmss.ffffff\Z");
case 23: return ParseUtc(s, @"yyyyMMddHHmmss.fffffff\Z");
default:
throw new FormatException();
}
}
int signIndex = IndexOfSign(s, System.Math.Max(10, s.Length - 5));
if (signIndex < 0)
{
switch (s.Length)
{
case 10: return ParseLocal(s, @"yyyyMMddHH");
case 12: return ParseLocal(s, @"yyyyMMddHHmm");
case 14: return ParseLocal(s, @"yyyyMMddHHmmss");
case 16: return ParseLocal(s, @"yyyyMMddHHmmss.f");
case 17: return ParseLocal(s, @"yyyyMMddHHmmss.ff");
case 18: return ParseLocal(s, @"yyyyMMddHHmmss.fff");
case 19: return ParseLocal(s, @"yyyyMMddHHmmss.ffff");
case 20: return ParseLocal(s, @"yyyyMMddHHmmss.fffff");
case 21: return ParseLocal(s, @"yyyyMMddHHmmss.ffffff");
case 22: return ParseLocal(s, @"yyyyMMddHHmmss.fffffff");
default:
throw new FormatException();
}
}
if (signIndex == s.Length - 5)
{
switch (s.Length)
{
case 15: return ParseTimeZone(s, @"yyyyMMddHHzzz");
case 17: return ParseTimeZone(s, @"yyyyMMddHHmmzzz");
case 19: return ParseTimeZone(s, @"yyyyMMddHHmmsszzz");
case 21: return ParseTimeZone(s, @"yyyyMMddHHmmss.fzzz");
case 22: return ParseTimeZone(s, @"yyyyMMddHHmmss.ffzzz");
case 23: return ParseTimeZone(s, @"yyyyMMddHHmmss.fffzzz");
case 24: return ParseTimeZone(s, @"yyyyMMddHHmmss.ffffzzz");
case 25: return ParseTimeZone(s, @"yyyyMMddHHmmss.fffffzzz");
case 26: return ParseTimeZone(s, @"yyyyMMddHHmmss.ffffffzzz");
case 27: return ParseTimeZone(s, @"yyyyMMddHHmmss.fffffffzzz");
default:
throw new FormatException();
}
}
if (signIndex == s.Length - 3)
{
switch (s.Length)
{
case 13: return ParseTimeZone(s, @"yyyyMMddHHzz");
case 15: return ParseTimeZone(s, @"yyyyMMddHHmmzz");
case 17: return ParseTimeZone(s, @"yyyyMMddHHmmsszz");
case 19: return ParseTimeZone(s, @"yyyyMMddHHmmss.fzz");
case 20: return ParseTimeZone(s, @"yyyyMMddHHmmss.ffzz");
case 21: return ParseTimeZone(s, @"yyyyMMddHHmmss.fffzz");
case 22: return ParseTimeZone(s, @"yyyyMMddHHmmss.ffffzz");
case 23: return ParseTimeZone(s, @"yyyyMMddHHmmss.fffffzz");
case 24: return ParseTimeZone(s, @"yyyyMMddHHmmss.ffffffzz");
case 25: return ParseTimeZone(s, @"yyyyMMddHHmmss.fffffffzz");
default:
throw new FormatException();
}
}
throw new FormatException();
}
private static int IndexOfSign(string s, int startIndex)
{
int index = Platform.IndexOf(s, '+', startIndex);
if (index < 0)
{
index = Platform.IndexOf(s, '-', startIndex);
}
return index;
}
private static DateTime ParseLocal(string s, string format)
{
return DateTime.ParseExact(s, format, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeLocal);
}
private static DateTime ParseTimeZone(string s, string format)
{
return DateTime.ParseExact(s, format, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AdjustToUniversal);
}
private static DateTime ParseUtc(string s, string format)
{
return DateTime.ParseExact(s, format, DateTimeFormatInfo.InvariantInfo,
DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
}
private static string ToStringCanonical(DateTime dateTime)
{
return dateTime.ToUniversalTime().ToString(@"yyyyMMddHHmmss.FFFFFFFK", DateTimeFormatInfo.InvariantInfo);
}
}
}
|
