Source file src/pkg/encoding/asn1/common.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
     6	
     7	import (
     8		"reflect"
     9		"strconv"
    10		"strings"
    11	)
    12	
    13	// ASN.1 objects have metadata preceding them:
    14	//   the tag: the type of the object
    15	//   a flag denoting if this object is compound or not
    16	//   the class type: the namespace of the tag
    17	//   the length of the object, in bytes
    18	
    19	// Here are some standard tags and classes
    20	
    21	const (
    22		tagBoolean         = 1
    23		tagInteger         = 2
    24		tagBitString       = 3
    25		tagOctetString     = 4
    26		tagOID             = 6
    27		tagEnum            = 10
    28		tagUTF8String      = 12
    29		tagSequence        = 16
    30		tagSet             = 17
    31		tagPrintableString = 19
    32		tagT61String       = 20
    33		tagIA5String       = 22
    34		tagUTCTime         = 23
    35		tagGeneralizedTime = 24
    36		tagGeneralString   = 27
    37	)
    38	
    39	const (
    40		classUniversal       = 0
    41		classApplication     = 1
    42		classContextSpecific = 2
    43		classPrivate         = 3
    44	)
    45	
    46	type tagAndLength struct {
    47		class, tag, length int
    48		isCompound         bool
    49	}
    50	
    51	// ASN.1 has IMPLICIT and EXPLICIT tags, which can be translated as "instead
    52	// of" and "in addition to". When not specified, every primitive type has a
    53	// default tag in the UNIVERSAL class.
    54	//
    55	// For example: a BIT STRING is tagged [UNIVERSAL 3] by default (although ASN.1
    56	// doesn't actually have a UNIVERSAL keyword). However, by saying [IMPLICIT
    57	// CONTEXT-SPECIFIC 42], that means that the tag is replaced by another.
    58	//
    59	// On the other hand, if it said [EXPLICIT CONTEXT-SPECIFIC 10], then an
    60	// /additional/ tag would wrap the default tag. This explicit tag will have the
    61	// compound flag set.
    62	//
    63	// (This is used in order to remove ambiguity with optional elements.)
    64	//
    65	// You can layer EXPLICIT and IMPLICIT tags to an arbitrary depth, however we
    66	// don't support that here. We support a single layer of EXPLICIT or IMPLICIT
    67	// tagging with tag strings on the fields of a structure.
    68	
    69	// fieldParameters is the parsed representation of tag string from a structure field.
    70	type fieldParameters struct {
    71		optional     bool   // true iff the field is OPTIONAL
    72		explicit     bool   // true iff an EXPLICIT tag is in use.
    73		application  bool   // true iff an APPLICATION tag is in use.
    74		defaultValue *int64 // a default value for INTEGER typed fields (maybe nil).
    75		tag          *int   // the EXPLICIT or IMPLICIT tag (maybe nil).
    76		stringType   int    // the string tag to use when marshaling.
    77		set          bool   // true iff this should be encoded as a SET
    78		omitEmpty    bool   // true iff this should be omitted if empty when marshaling.
    79	
    80		// Invariants:
    81		//   if explicit is set, tag is non-nil.
    82	}
    83	
    84	// Given a tag string with the format specified in the package comment,
    85	// parseFieldParameters will parse it into a fieldParameters structure,
    86	// ignoring unknown parts of the string.
    87	func parseFieldParameters(str string) (ret fieldParameters) {
    88		for _, part := range strings.Split(str, ",") {
    89			switch {
    90			case part == "optional":
    91				ret.optional = true
    92			case part == "explicit":
    93				ret.explicit = true
    94				if ret.tag == nil {
    95					ret.tag = new(int)
    96				}
    97			case part == "ia5":
    98				ret.stringType = tagIA5String
    99			case part == "printable":
   100				ret.stringType = tagPrintableString
   101			case strings.HasPrefix(part, "default:"):
   102				i, err := strconv.ParseInt(part[8:], 10, 64)
   103				if err == nil {
   104					ret.defaultValue = new(int64)
   105					*ret.defaultValue = i
   106				}
   107			case strings.HasPrefix(part, "tag:"):
   108				i, err := strconv.Atoi(part[4:])
   109				if err == nil {
   110					ret.tag = new(int)
   111					*ret.tag = i
   112				}
   113			case part == "set":
   114				ret.set = true
   115			case part == "application":
   116				ret.application = true
   117				if ret.tag == nil {
   118					ret.tag = new(int)
   119				}
   120			case part == "omitempty":
   121				ret.omitEmpty = true
   122			}
   123		}
   124		return
   125	}
   126	
   127	// Given a reflected Go type, getUniversalType returns the default tag number
   128	// and expected compound flag.
   129	func getUniversalType(t reflect.Type) (tagNumber int, isCompound, ok bool) {
   130		switch t {
   131		case objectIdentifierType:
   132			return tagOID, false, true
   133		case bitStringType:
   134			return tagBitString, false, true
   135		case timeType:
   136			return tagUTCTime, false, true
   137		case enumeratedType:
   138			return tagEnum, false, true
   139		case bigIntType:
   140			return tagInteger, false, true
   141		}
   142		switch t.Kind() {
   143		case reflect.Bool:
   144			return tagBoolean, false, true
   145		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   146			return tagInteger, false, true
   147		case reflect.Struct:
   148			return tagSequence, true, true
   149		case reflect.Slice:
   150			if t.Elem().Kind() == reflect.Uint8 {
   151				return tagOctetString, false, true
   152			}
   153			if strings.HasSuffix(t.Name(), "SET") {
   154				return tagSet, true, true
   155			}
   156			return tagSequence, true, true
   157		case reflect.String:
   158			return tagPrintableString, false, true
   159		}
   160		return 0, false, false
   161	}