Source file src/pkg/encoding/asn1/asn1.go

     1	// Copyright 2009 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// Package asn1 implements parsing of DER-encoded ASN.1 data structures,
     6	// as defined in ITU-T Rec X.690.
     7	//
     8	// See also ``A Layman's Guide to a Subset of ASN.1, BER, and DER,''
     9	// http://luca.ntop.org/Teaching/Appunti/asn1.html.
    10	package asn1
    11	
    12	// ASN.1 is a syntax for specifying abstract objects and BER, DER, PER, XER etc
    13	// are different encoding formats for those objects. Here, we'll be dealing
    14	// with DER, the Distinguished Encoding Rules. DER is used in X.509 because
    15	// it's fast to parse and, unlike BER, has a unique encoding for every object.
    16	// When calculating hashes over objects, it's important that the resulting
    17	// bytes be the same at both ends and DER removes this margin of error.
    18	//
    19	// ASN.1 is very complex and this package doesn't attempt to implement
    20	// everything by any means.
    21	
    22	import (
    23		"fmt"
    24		"math/big"
    25		"reflect"
    26		"time"
    27	)
    28	
    29	// A StructuralError suggests that the ASN.1 data is valid, but the Go type
    30	// which is receiving it doesn't match.
    31	type StructuralError struct {
    32		Msg string
    33	}
    34	
    35	func (e StructuralError) Error() string { return "ASN.1 structure error: " + e.Msg }
    36	
    37	// A SyntaxError suggests that the ASN.1 data is invalid.
    38	type SyntaxError struct {
    39		Msg string
    40	}
    41	
    42	func (e SyntaxError) Error() string { return "ASN.1 syntax error: " + e.Msg }
    43	
    44	// We start by dealing with each of the primitive types in turn.
    45	
    46	// BOOLEAN
    47	
    48	func parseBool(bytes []byte) (ret bool, err error) {
    49		if len(bytes) != 1 {
    50			err = SyntaxError{"invalid boolean"}
    51			return
    52		}
    53	
    54		return bytes[0] != 0, nil
    55	}
    56	
    57	// INTEGER
    58	
    59	// parseInt64 treats the given bytes as a big-endian, signed integer and
    60	// returns the result.
    61	func parseInt64(bytes []byte) (ret int64, err error) {
    62		if len(bytes) > 8 {
    63			// We'll overflow an int64 in this case.
    64			err = StructuralError{"integer too large"}
    65			return
    66		}
    67		for bytesRead := 0; bytesRead < len(bytes); bytesRead++ {
    68			ret <<= 8
    69			ret |= int64(bytes[bytesRead])
    70		}
    71	
    72		// Shift up and down in order to sign extend the result.
    73		ret <<= 64 - uint8(len(bytes))*8
    74		ret >>= 64 - uint8(len(bytes))*8
    75		return
    76	}
    77	
    78	// parseInt treats the given bytes as a big-endian, signed integer and returns
    79	// the result.
    80	func parseInt(bytes []byte) (int, error) {
    81		ret64, err := parseInt64(bytes)
    82		if err != nil {
    83			return 0, err
    84		}
    85		if ret64 != int64(int(ret64)) {
    86			return 0, StructuralError{"integer too large"}
    87		}
    88		return int(ret64), nil
    89	}
    90	
    91	var bigOne = big.NewInt(1)
    92	
    93	// parseBigInt treats the given bytes as a big-endian, signed integer and returns
    94	// the result.
    95	func parseBigInt(bytes []byte) *big.Int {
    96		ret := new(big.Int)
    97		if len(bytes) > 0 && bytes[0]&0x80 == 0x80 {
    98			// This is a negative number.
    99			notBytes := make([]byte, len(bytes))
   100			for i := range notBytes {
   101				notBytes[i] = ^bytes[i]
   102			}
   103			ret.SetBytes(notBytes)
   104			ret.Add(ret, bigOne)
   105			ret.Neg(ret)
   106			return ret
   107		}
   108		ret.SetBytes(bytes)
   109		return ret
   110	}
   111	
   112	// BIT STRING
   113	
   114	// BitString is the structure to use when you want an ASN.1 BIT STRING type. A
   115	// bit string is padded up to the nearest byte in memory and the number of
   116	// valid bits is recorded. Padding bits will be zero.
   117	type BitString struct {
   118		Bytes     []byte // bits packed into bytes.
   119		BitLength int    // length in bits.
   120	}
   121	
   122	// At returns the bit at the given index. If the index is out of range it
   123	// returns false.
   124	func (b BitString) At(i int) int {
   125		if i < 0 || i >= b.BitLength {
   126			return 0
   127		}
   128		x := i / 8
   129		y := 7 - uint(i%8)
   130		return int(b.Bytes[x]>>y) & 1
   131	}
   132	
   133	// RightAlign returns a slice where the padding bits are at the beginning. The
   134	// slice may share memory with the BitString.
   135	func (b BitString) RightAlign() []byte {
   136		shift := uint(8 - (b.BitLength % 8))
   137		if shift == 8 || len(b.Bytes) == 0 {
   138			return b.Bytes
   139		}
   140	
   141		a := make([]byte, len(b.Bytes))
   142		a[0] = b.Bytes[0] >> shift
   143		for i := 1; i < len(b.Bytes); i++ {
   144			a[i] = b.Bytes[i-1] << (8 - shift)
   145			a[i] |= b.Bytes[i] >> shift
   146		}
   147	
   148		return a
   149	}
   150	
   151	// parseBitString parses an ASN.1 bit string from the given byte slice and returns it.
   152	func parseBitString(bytes []byte) (ret BitString, err error) {
   153		if len(bytes) == 0 {
   154			err = SyntaxError{"zero length BIT STRING"}
   155			return
   156		}
   157		paddingBits := int(bytes[0])
   158		if paddingBits > 7 ||
   159			len(bytes) == 1 && paddingBits > 0 ||
   160			bytes[len(bytes)-1]&((1<<bytes[0])-1) != 0 {
   161			err = SyntaxError{"invalid padding bits in BIT STRING"}
   162			return
   163		}
   164		ret.BitLength = (len(bytes)-1)*8 - paddingBits
   165		ret.Bytes = bytes[1:]
   166		return
   167	}
   168	
   169	// OBJECT IDENTIFIER
   170	
   171	// An ObjectIdentifier represents an ASN.1 OBJECT IDENTIFIER.
   172	type ObjectIdentifier []int
   173	
   174	// Equal returns true iff oi and other represent the same identifier.
   175	func (oi ObjectIdentifier) Equal(other ObjectIdentifier) bool {
   176		if len(oi) != len(other) {
   177			return false
   178		}
   179		for i := 0; i < len(oi); i++ {
   180			if oi[i] != other[i] {
   181				return false
   182			}
   183		}
   184	
   185		return true
   186	}
   187	
   188	// parseObjectIdentifier parses an OBJECT IDENTIFIER from the given bytes and
   189	// returns it. An object identifier is a sequence of variable length integers
   190	// that are assigned in a hierarchy.
   191	func parseObjectIdentifier(bytes []byte) (s []int, err error) {
   192		if len(bytes) == 0 {
   193			err = SyntaxError{"zero length OBJECT IDENTIFIER"}
   194			return
   195		}
   196	
   197		// In the worst case, we get two elements from the first byte (which is
   198		// encoded differently) and then every varint is a single byte long.
   199		s = make([]int, len(bytes)+1)
   200	
   201		// The first byte is 40*value1 + value2:
   202		s[0] = int(bytes[0]) / 40
   203		s[1] = int(bytes[0]) % 40
   204		i := 2
   205		for offset := 1; offset < len(bytes); i++ {
   206			var v int
   207			v, offset, err = parseBase128Int(bytes, offset)
   208			if err != nil {
   209				return
   210			}
   211			s[i] = v
   212		}
   213		s = s[0:i]
   214		return
   215	}
   216	
   217	// ENUMERATED
   218	
   219	// An Enumerated is represented as a plain int.
   220	type Enumerated int
   221	
   222	// FLAG
   223	
   224	// A Flag accepts any data and is set to true if present.
   225	type Flag bool
   226	
   227	// parseBase128Int parses a base-128 encoded int from the given offset in the
   228	// given byte slice. It returns the value and the new offset.
   229	func parseBase128Int(bytes []byte, initOffset int) (ret, offset int, err error) {
   230		offset = initOffset
   231		for shifted := 0; offset < len(bytes); shifted++ {
   232			if shifted > 4 {
   233				err = StructuralError{"base 128 integer too large"}
   234				return
   235			}
   236			ret <<= 7
   237			b := bytes[offset]
   238			ret |= int(b & 0x7f)
   239			offset++
   240			if b&0x80 == 0 {
   241				return
   242			}
   243		}
   244		err = SyntaxError{"truncated base 128 integer"}
   245		return
   246	}
   247	
   248	// UTCTime
   249	
   250	func parseUTCTime(bytes []byte) (ret time.Time, err error) {
   251		s := string(bytes)
   252		ret, err = time.Parse("0601021504Z0700", s)
   253		if err != nil {
   254			ret, err = time.Parse("060102150405Z0700", s)
   255		}
   256		if err == nil && ret.Year() >= 2050 {
   257			// UTCTime only encodes times prior to 2050. See https://tools.ietf.org/html/rfc5280#section-4.1.2.5.1
   258			ret = ret.AddDate(-100, 0, 0)
   259		}
   260	
   261		return
   262	}
   263	
   264	// parseGeneralizedTime parses the GeneralizedTime from the given byte slice
   265	// and returns the resulting time.
   266	func parseGeneralizedTime(bytes []byte) (ret time.Time, err error) {
   267		return time.Parse("20060102150405Z0700", string(bytes))
   268	}
   269	
   270	// PrintableString
   271	
   272	// parsePrintableString parses a ASN.1 PrintableString from the given byte
   273	// array and returns it.
   274	func parsePrintableString(bytes []byte) (ret string, err error) {
   275		for _, b := range bytes {
   276			if !isPrintable(b) {
   277				err = SyntaxError{"PrintableString contains invalid character"}
   278				return
   279			}
   280		}
   281		ret = string(bytes)
   282		return
   283	}
   284	
   285	// isPrintable returns true iff the given b is in the ASN.1 PrintableString set.
   286	func isPrintable(b byte) bool {
   287		return 'a' <= b && b <= 'z' ||
   288			'A' <= b && b <= 'Z' ||
   289			'0' <= b && b <= '9' ||
   290			'\'' <= b && b <= ')' ||
   291			'+' <= b && b <= '/' ||
   292			b == ' ' ||
   293			b == ':' ||
   294			b == '=' ||
   295			b == '?' ||
   296			// This is technically not allowed in a PrintableString.
   297			// However, x509 certificates with wildcard strings don't
   298			// always use the correct string type so we permit it.
   299			b == '*'
   300	}
   301	
   302	// IA5String
   303	
   304	// parseIA5String parses a ASN.1 IA5String (ASCII string) from the given
   305	// byte slice and returns it.
   306	func parseIA5String(bytes []byte) (ret string, err error) {
   307		for _, b := range bytes {
   308			if b >= 0x80 {
   309				err = SyntaxError{"IA5String contains invalid character"}
   310				return
   311			}
   312		}
   313		ret = string(bytes)
   314		return
   315	}
   316	
   317	// T61String
   318	
   319	// parseT61String parses a ASN.1 T61String (8-bit clean string) from the given
   320	// byte slice and returns it.
   321	func parseT61String(bytes []byte) (ret string, err error) {
   322		return string(bytes), nil
   323	}
   324	
   325	// UTF8String
   326	
   327	// parseUTF8String parses a ASN.1 UTF8String (raw UTF-8) from the given byte
   328	// array and returns it.
   329	func parseUTF8String(bytes []byte) (ret string, err error) {
   330		return string(bytes), nil
   331	}
   332	
   333	// A RawValue represents an undecoded ASN.1 object.
   334	type RawValue struct {
   335		Class, Tag int
   336		IsCompound bool
   337		Bytes      []byte
   338		FullBytes  []byte // includes the tag and length
   339	}
   340	
   341	// RawContent is used to signal that the undecoded, DER data needs to be
   342	// preserved for a struct. To use it, the first field of the struct must have
   343	// this type. It's an error for any of the other fields to have this type.
   344	type RawContent []byte
   345	
   346	// Tagging
   347	
   348	// parseTagAndLength parses an ASN.1 tag and length pair from the given offset
   349	// into a byte slice. It returns the parsed data and the new offset. SET and
   350	// SET OF (tag 17) are mapped to SEQUENCE and SEQUENCE OF (tag 16) since we
   351	// don't distinguish between ordered and unordered objects in this code.
   352	func parseTagAndLength(bytes []byte, initOffset int) (ret tagAndLength, offset int, err error) {
   353		offset = initOffset
   354		b := bytes[offset]
   355		offset++
   356		ret.class = int(b >> 6)
   357		ret.isCompound = b&0x20 == 0x20
   358		ret.tag = int(b & 0x1f)
   359	
   360		// If the bottom five bits are set, then the tag number is actually base 128
   361		// encoded afterwards
   362		if ret.tag == 0x1f {
   363			ret.tag, offset, err = parseBase128Int(bytes, offset)
   364			if err != nil {
   365				return
   366			}
   367		}
   368		if offset >= len(bytes) {
   369			err = SyntaxError{"truncated tag or length"}
   370			return
   371		}
   372		b = bytes[offset]
   373		offset++
   374		if b&0x80 == 0 {
   375			// The length is encoded in the bottom 7 bits.
   376			ret.length = int(b & 0x7f)
   377		} else {
   378			// Bottom 7 bits give the number of length bytes to follow.
   379			numBytes := int(b & 0x7f)
   380			if numBytes == 0 {
   381				err = SyntaxError{"indefinite length found (not DER)"}
   382				return
   383			}
   384			ret.length = 0
   385			for i := 0; i < numBytes; i++ {
   386				if offset >= len(bytes) {
   387					err = SyntaxError{"truncated tag or length"}
   388					return
   389				}
   390				b = bytes[offset]
   391				offset++
   392				if ret.length >= 1<<23 {
   393					// We can't shift ret.length up without
   394					// overflowing.
   395					err = StructuralError{"length too large"}
   396					return
   397				}
   398				ret.length <<= 8
   399				ret.length |= int(b)
   400				if ret.length == 0 {
   401					// DER requires that lengths be minimal.
   402					err = StructuralError{"superfluous leading zeros in length"}
   403					return
   404				}
   405			}
   406		}
   407	
   408		return
   409	}
   410	
   411	// parseSequenceOf is used for SEQUENCE OF and SET OF values. It tries to parse
   412	// a number of ASN.1 values from the given byte slice and returns them as a
   413	// slice of Go values of the given type.
   414	func parseSequenceOf(bytes []byte, sliceType reflect.Type, elemType reflect.Type) (ret reflect.Value, err error) {
   415		expectedTag, compoundType, ok := getUniversalType(elemType)
   416		if !ok {
   417			err = StructuralError{"unknown Go type for slice"}
   418			return
   419		}
   420	
   421		// First we iterate over the input and count the number of elements,
   422		// checking that the types are correct in each case.
   423		numElements := 0
   424		for offset := 0; offset < len(bytes); {
   425			var t tagAndLength
   426			t, offset, err = parseTagAndLength(bytes, offset)
   427			if err != nil {
   428				return
   429			}
   430			// We pretend that GENERAL STRINGs are PRINTABLE STRINGs so
   431			// that a sequence of them can be parsed into a []string.
   432			if t.tag == tagGeneralString {
   433				t.tag = tagPrintableString
   434			}
   435			if t.class != classUniversal || t.isCompound != compoundType || t.tag != expectedTag {
   436				err = StructuralError{"sequence tag mismatch"}
   437				return
   438			}
   439			if invalidLength(offset, t.length, len(bytes)) {
   440				err = SyntaxError{"truncated sequence"}
   441				return
   442			}
   443			offset += t.length
   444			numElements++
   445		}
   446		ret = reflect.MakeSlice(sliceType, numElements, numElements)
   447		params := fieldParameters{}
   448		offset := 0
   449		for i := 0; i < numElements; i++ {
   450			offset, err = parseField(ret.Index(i), bytes, offset, params)
   451			if err != nil {
   452				return
   453			}
   454		}
   455		return
   456	}
   457	
   458	var (
   459		bitStringType        = reflect.TypeOf(BitString{})
   460		objectIdentifierType = reflect.TypeOf(ObjectIdentifier{})
   461		enumeratedType       = reflect.TypeOf(Enumerated(0))
   462		flagType             = reflect.TypeOf(Flag(false))
   463		timeType             = reflect.TypeOf(time.Time{})
   464		rawValueType         = reflect.TypeOf(RawValue{})
   465		rawContentsType      = reflect.TypeOf(RawContent(nil))
   466		bigIntType           = reflect.TypeOf(new(big.Int))
   467	)
   468	
   469	// invalidLength returns true iff offset + length > sliceLength, or if the
   470	// addition would overflow.
   471	func invalidLength(offset, length, sliceLength int) bool {
   472		return offset+length < offset || offset+length > sliceLength
   473	}
   474	
   475	// parseField is the main parsing function. Given a byte slice and an offset
   476	// into the array, it will try to parse a suitable ASN.1 value out and store it
   477	// in the given Value.
   478	func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParameters) (offset int, err error) {
   479		offset = initOffset
   480		fieldType := v.Type()
   481	
   482		// If we have run out of data, it may be that there are optional elements at the end.
   483		if offset == len(bytes) {
   484			if !setDefaultValue(v, params) {
   485				err = SyntaxError{"sequence truncated"}
   486			}
   487			return
   488		}
   489	
   490		// Deal with raw values.
   491		if fieldType == rawValueType {
   492			var t tagAndLength
   493			t, offset, err = parseTagAndLength(bytes, offset)
   494			if err != nil {
   495				return
   496			}
   497			if invalidLength(offset, t.length, len(bytes)) {
   498				err = SyntaxError{"data truncated"}
   499				return
   500			}
   501			result := RawValue{t.class, t.tag, t.isCompound, bytes[offset : offset+t.length], bytes[initOffset : offset+t.length]}
   502			offset += t.length
   503			v.Set(reflect.ValueOf(result))
   504			return
   505		}
   506	
   507		// Deal with the ANY type.
   508		if ifaceType := fieldType; ifaceType.Kind() == reflect.Interface && ifaceType.NumMethod() == 0 {
   509			var t tagAndLength
   510			t, offset, err = parseTagAndLength(bytes, offset)
   511			if err != nil {
   512				return
   513			}
   514			if invalidLength(offset, t.length, len(bytes)) {
   515				err = SyntaxError{"data truncated"}
   516				return
   517			}
   518			var result interface{}
   519			if !t.isCompound && t.class == classUniversal {
   520				innerBytes := bytes[offset : offset+t.length]
   521				switch t.tag {
   522				case tagPrintableString:
   523					result, err = parsePrintableString(innerBytes)
   524				case tagIA5String:
   525					result, err = parseIA5String(innerBytes)
   526				case tagT61String:
   527					result, err = parseT61String(innerBytes)
   528				case tagUTF8String:
   529					result, err = parseUTF8String(innerBytes)
   530				case tagInteger:
   531					result, err = parseInt64(innerBytes)
   532				case tagBitString:
   533					result, err = parseBitString(innerBytes)
   534				case tagOID:
   535					result, err = parseObjectIdentifier(innerBytes)
   536				case tagUTCTime:
   537					result, err = parseUTCTime(innerBytes)
   538				case tagOctetString:
   539					result = innerBytes
   540				default:
   541					// If we don't know how to handle the type, we just leave Value as nil.
   542				}
   543			}
   544			offset += t.length
   545			if err != nil {
   546				return
   547			}
   548			if result != nil {
   549				v.Set(reflect.ValueOf(result))
   550			}
   551			return
   552		}
   553		universalTag, compoundType, ok1 := getUniversalType(fieldType)
   554		if !ok1 {
   555			err = StructuralError{fmt.Sprintf("unknown Go type: %v", fieldType)}
   556			return
   557		}
   558	
   559		t, offset, err := parseTagAndLength(bytes, offset)
   560		if err != nil {
   561			return
   562		}
   563		if params.explicit {
   564			expectedClass := classContextSpecific
   565			if params.application {
   566				expectedClass = classApplication
   567			}
   568			if t.class == expectedClass && t.tag == *params.tag && (t.length == 0 || t.isCompound) {
   569				if t.length > 0 {
   570					t, offset, err = parseTagAndLength(bytes, offset)
   571					if err != nil {
   572						return
   573					}
   574				} else {
   575					if fieldType != flagType {
   576						err = StructuralError{"Zero length explicit tag was not an asn1.Flag"}
   577						return
   578					}
   579					v.SetBool(true)
   580					return
   581				}
   582			} else {
   583				// The tags didn't match, it might be an optional element.
   584				ok := setDefaultValue(v, params)
   585				if ok {
   586					offset = initOffset
   587				} else {
   588					err = StructuralError{"explicitly tagged member didn't match"}
   589				}
   590				return
   591			}
   592		}
   593	
   594		// Special case for strings: all the ASN.1 string types map to the Go
   595		// type string. getUniversalType returns the tag for PrintableString
   596		// when it sees a string, so if we see a different string type on the
   597		// wire, we change the universal type to match.
   598		if universalTag == tagPrintableString {
   599			switch t.tag {
   600			case tagIA5String, tagGeneralString, tagT61String, tagUTF8String:
   601				universalTag = t.tag
   602			}
   603		}
   604	
   605		// Special case for time: UTCTime and GeneralizedTime both map to the
   606		// Go type time.Time.
   607		if universalTag == tagUTCTime && t.tag == tagGeneralizedTime {
   608			universalTag = tagGeneralizedTime
   609		}
   610	
   611		expectedClass := classUniversal
   612		expectedTag := universalTag
   613	
   614		if !params.explicit && params.tag != nil {
   615			expectedClass = classContextSpecific
   616			expectedTag = *params.tag
   617		}
   618	
   619		if !params.explicit && params.application && params.tag != nil {
   620			expectedClass = classApplication
   621			expectedTag = *params.tag
   622		}
   623	
   624		// We have unwrapped any explicit tagging at this point.
   625		if t.class != expectedClass || t.tag != expectedTag || t.isCompound != compoundType {
   626			// Tags don't match. Again, it could be an optional element.
   627			ok := setDefaultValue(v, params)
   628			if ok {
   629				offset = initOffset
   630			} else {
   631				err = StructuralError{fmt.Sprintf("tags don't match (%d vs %+v) %+v %s @%d", expectedTag, t, params, fieldType.Name(), offset)}
   632			}
   633			return
   634		}
   635		if invalidLength(offset, t.length, len(bytes)) {
   636			err = SyntaxError{"data truncated"}
   637			return
   638		}
   639		innerBytes := bytes[offset : offset+t.length]
   640		offset += t.length
   641	
   642		// We deal with the structures defined in this package first.
   643		switch fieldType {
   644		case objectIdentifierType:
   645			newSlice, err1 := parseObjectIdentifier(innerBytes)
   646			v.Set(reflect.MakeSlice(v.Type(), len(newSlice), len(newSlice)))
   647			if err1 == nil {
   648				reflect.Copy(v, reflect.ValueOf(newSlice))
   649			}
   650			err = err1
   651			return
   652		case bitStringType:
   653			bs, err1 := parseBitString(innerBytes)
   654			if err1 == nil {
   655				v.Set(reflect.ValueOf(bs))
   656			}
   657			err = err1
   658			return
   659		case timeType:
   660			var time time.Time
   661			var err1 error
   662			if universalTag == tagUTCTime {
   663				time, err1 = parseUTCTime(innerBytes)
   664			} else {
   665				time, err1 = parseGeneralizedTime(innerBytes)
   666			}
   667			if err1 == nil {
   668				v.Set(reflect.ValueOf(time))
   669			}
   670			err = err1
   671			return
   672		case enumeratedType:
   673			parsedInt, err1 := parseInt(innerBytes)
   674			if err1 == nil {
   675				v.SetInt(int64(parsedInt))
   676			}
   677			err = err1
   678			return
   679		case flagType:
   680			v.SetBool(true)
   681			return
   682		case bigIntType:
   683			parsedInt := parseBigInt(innerBytes)
   684			v.Set(reflect.ValueOf(parsedInt))
   685			return
   686		}
   687		switch val := v; val.Kind() {
   688		case reflect.Bool:
   689			parsedBool, err1 := parseBool(innerBytes)
   690			if err1 == nil {
   691				val.SetBool(parsedBool)
   692			}
   693			err = err1
   694			return
   695		case reflect.Int, reflect.Int32:
   696			parsedInt, err1 := parseInt(innerBytes)
   697			if err1 == nil {
   698				val.SetInt(int64(parsedInt))
   699			}
   700			err = err1
   701			return
   702		case reflect.Int64:
   703			parsedInt, err1 := parseInt64(innerBytes)
   704			if err1 == nil {
   705				val.SetInt(parsedInt)
   706			}
   707			err = err1
   708			return
   709		// TODO(dfc) Add support for the remaining integer types
   710		case reflect.Struct:
   711			structType := fieldType
   712	
   713			if structType.NumField() > 0 &&
   714				structType.Field(0).Type == rawContentsType {
   715				bytes := bytes[initOffset:offset]
   716				val.Field(0).Set(reflect.ValueOf(RawContent(bytes)))
   717			}
   718	
   719			innerOffset := 0
   720			for i := 0; i < structType.NumField(); i++ {
   721				field := structType.Field(i)
   722				if i == 0 && field.Type == rawContentsType {
   723					continue
   724				}
   725				innerOffset, err = parseField(val.Field(i), innerBytes, innerOffset, parseFieldParameters(field.Tag.Get("asn1")))
   726				if err != nil {
   727					return
   728				}
   729			}
   730			// We allow extra bytes at the end of the SEQUENCE because
   731			// adding elements to the end has been used in X.509 as the
   732			// version numbers have increased.
   733			return
   734		case reflect.Slice:
   735			sliceType := fieldType
   736			if sliceType.Elem().Kind() == reflect.Uint8 {
   737				val.Set(reflect.MakeSlice(sliceType, len(innerBytes), len(innerBytes)))
   738				reflect.Copy(val, reflect.ValueOf(innerBytes))
   739				return
   740			}
   741			newSlice, err1 := parseSequenceOf(innerBytes, sliceType, sliceType.Elem())
   742			if err1 == nil {
   743				val.Set(newSlice)
   744			}
   745			err = err1
   746			return
   747		case reflect.String:
   748			var v string
   749			switch universalTag {
   750			case tagPrintableString:
   751				v, err = parsePrintableString(innerBytes)
   752			case tagIA5String:
   753				v, err = parseIA5String(innerBytes)
   754			case tagT61String:
   755				v, err = parseT61String(innerBytes)
   756			case tagUTF8String:
   757				v, err = parseUTF8String(innerBytes)
   758			case tagGeneralString:
   759				// GeneralString is specified in ISO-2022/ECMA-35,
   760				// A brief review suggests that it includes structures
   761				// that allow the encoding to change midstring and
   762				// such. We give up and pass it as an 8-bit string.
   763				v, err = parseT61String(innerBytes)
   764			default:
   765				err = SyntaxError{fmt.Sprintf("internal error: unknown string type %d", universalTag)}
   766			}
   767			if err == nil {
   768				val.SetString(v)
   769			}
   770			return
   771		}
   772		err = StructuralError{"unsupported: " + v.Type().String()}
   773		return
   774	}
   775	
   776	// setDefaultValue is used to install a default value, from a tag string, into
   777	// a Value. It is successful is the field was optional, even if a default value
   778	// wasn't provided or it failed to install it into the Value.
   779	func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) {
   780		if !params.optional {
   781			return
   782		}
   783		ok = true
   784		if params.defaultValue == nil {
   785			return
   786		}
   787		switch val := v; val.Kind() {
   788		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   789			val.SetInt(*params.defaultValue)
   790		}
   791		return
   792	}
   793	
   794	// Unmarshal parses the DER-encoded ASN.1 data structure b
   795	// and uses the reflect package to fill in an arbitrary value pointed at by val.
   796	// Because Unmarshal uses the reflect package, the structs
   797	// being written to must use upper case field names.
   798	//
   799	// An ASN.1 INTEGER can be written to an int, int32, int64,
   800	// or *big.Int (from the math/big package).
   801	// If the encoded value does not fit in the Go type,
   802	// Unmarshal returns a parse error.
   803	//
   804	// An ASN.1 BIT STRING can be written to a BitString.
   805	//
   806	// An ASN.1 OCTET STRING can be written to a []byte.
   807	//
   808	// An ASN.1 OBJECT IDENTIFIER can be written to an
   809	// ObjectIdentifier.
   810	//
   811	// An ASN.1 ENUMERATED can be written to an Enumerated.
   812	//
   813	// An ASN.1 UTCTIME or GENERALIZEDTIME can be written to a time.Time.
   814	//
   815	// An ASN.1 PrintableString or IA5String can be written to a string.
   816	//
   817	// Any of the above ASN.1 values can be written to an interface{}.
   818	// The value stored in the interface has the corresponding Go type.
   819	// For integers, that type is int64.
   820	//
   821	// An ASN.1 SEQUENCE OF x or SET OF x can be written
   822	// to a slice if an x can be written to the slice's element type.
   823	//
   824	// An ASN.1 SEQUENCE or SET can be written to a struct
   825	// if each of the elements in the sequence can be
   826	// written to the corresponding element in the struct.
   827	//
   828	// The following tags on struct fields have special meaning to Unmarshal:
   829	//
   830	//	optional		marks the field as ASN.1 OPTIONAL
   831	//	[explicit] tag:x	specifies the ASN.1 tag number; implies ASN.1 CONTEXT SPECIFIC
   832	//	default:x		sets the default value for optional integer fields
   833	//
   834	// If the type of the first field of a structure is RawContent then the raw
   835	// ASN1 contents of the struct will be stored in it.
   836	//
   837	// Other ASN.1 types are not supported; if it encounters them,
   838	// Unmarshal returns a parse error.
   839	func Unmarshal(b []byte, val interface{}) (rest []byte, err error) {
   840		return UnmarshalWithParams(b, val, "")
   841	}
   842	
   843	// UnmarshalWithParams allows field parameters to be specified for the
   844	// top-level element. The form of the params is the same as the field tags.
   845	func UnmarshalWithParams(b []byte, val interface{}, params string) (rest []byte, err error) {
   846		v := reflect.ValueOf(val).Elem()
   847		offset, err := parseField(v, b, 0, parseFieldParameters(params))
   848		if err != nil {
   849			return nil, err
   850		}
   851		return b[offset:], nil
   852	}