Asn1GeneralizedTime
GeneralizedTime ASN.1 type
using Org.BouncyCastle.Utilities;
using System;
using System.Globalization;
using System.IO;
using System.Text;
namespace Org.BouncyCastle.Asn1
{
public class Asn1GeneralizedTime : Asn1Object
{
internal class Meta : Asn1UniversalType
{
internal static readonly Asn1UniversalType Instance = new Meta();
private Meta()
: base(typeof(Asn1GeneralizedTime), 24)
{
}
internal override Asn1Object FromImplicitPrimitive(DerOctetString octetString)
{
return CreatePrimitive(octetString.GetOctets());
}
}
private readonly string m_timeString;
private readonly bool m_timeStringCanonical;
private readonly DateTime m_dateTime;
public string TimeString => m_timeString;
public static Asn1GeneralizedTime GetInstance(object obj)
{
if (obj == null)
return null;
Asn1GeneralizedTime asn1GeneralizedTime = obj as Asn1GeneralizedTime;
if (asn1GeneralizedTime != null)
return asn1GeneralizedTime;
IAsn1Convertible asn1Convertible = obj as IAsn1Convertible;
if (asn1Convertible != null) {
Asn1GeneralizedTime asn1GeneralizedTime2 = asn1Convertible.ToAsn1Object() as Asn1GeneralizedTime;
if (asn1GeneralizedTime2 != null)
return asn1GeneralizedTime2;
} else {
byte[] array = obj as byte[];
if (array != null)
try {
return (Asn1GeneralizedTime)Meta.Instance.FromByteArray(array);
} catch (IOException ex) {
throw new ArgumentException("failed to construct generalized time from byte[]: " + ex.Message);
}
}
throw new ArgumentException("illegal object in GetInstance: " + Platform.GetTypeName(obj), "obj");
}
public static Asn1GeneralizedTime GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
{
return (Asn1GeneralizedTime)Meta.Instance.GetContextInstance(taggedObject, declaredExplicit);
}
public Asn1GeneralizedTime(string timeString)
{
if (timeString == null)
throw new ArgumentNullException("timeString");
m_timeString = timeString;
m_timeStringCanonical = false;
try {
m_dateTime = FromString(timeString);
} catch (FormatException ex) {
throw new ArgumentException("invalid date string: " + ex.Message);
}
}
public Asn1GeneralizedTime(DateTime dateTime)
{
dateTime = dateTime.ToUniversalTime();
m_dateTime = dateTime;
m_timeString = ToStringCanonical(dateTime);
m_timeStringCanonical = true;
}
internal Asn1GeneralizedTime(byte[] contents)
: this(Encoding.ASCII.GetString(contents))
{
}
public DateTime ToDateTime()
{
return m_dateTime;
}
internal byte[] GetContents(int encoding)
{
if (encoding == 3 && !m_timeStringCanonical)
return Encoding.ASCII.GetBytes(ToStringCanonical(m_dateTime));
return Encoding.ASCII.GetBytes(m_timeString);
}
internal override IAsn1Encoding GetEncoding(int encoding)
{
return new PrimitiveEncoding(0, 24, GetContents(encoding));
}
internal override IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo)
{
return new PrimitiveEncoding(tagClass, tagNo, GetContents(encoding));
}
internal sealed override DerEncoding GetEncodingDer()
{
return new PrimitiveDerEncoding(0, 24, GetContents(3));
}
internal sealed override DerEncoding GetEncodingDerImplicit(int tagClass, int tagNo)
{
return new PrimitiveDerEncoding(tagClass, tagNo, GetContents(3));
}
protected override bool Asn1Equals(Asn1Object asn1Object)
{
Asn1GeneralizedTime asn1GeneralizedTime = asn1Object as Asn1GeneralizedTime;
if (asn1GeneralizedTime == null)
return false;
return Arrays.AreEqual(GetContents(3), asn1GeneralizedTime.GetContents(3));
}
protected override int Asn1GetHashCode()
{
return Arrays.GetHashCode(GetContents(3));
}
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 num = IndexOfSign(s, System.Math.Max(10, s.Length - 5));
if (num < 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 (num == 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 (num == 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 num = Platform.IndexOf(s, '+', startIndex);
if (num < 0)
num = Platform.IndexOf(s, '-', startIndex);
return num;
}
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);
}
}
}