diff --git a/.travis.yml b/.travis.yml index 8d7d11f..44aa48b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -2,11 +2,14 @@ go: - 1.2 - 1.3 + - 1.4 + - 1.5 - tip +go_import_path: gopkg.in/asn-ber.v1 install: - go list -f '{{range .Imports}}{{.}} {{end}}' ./... | xargs go get -v - go list -f '{{range .TestImports}}{{.}} {{end}}' ./... | xargs go get -v - - go get code.google.com/p/go.tools/cmd/cover + - go get code.google.com/p/go.tools/cmd/cover || go get golang.org/x/tools/cmd/cover - go build -v ./... script: - go test -v -cover ./... diff --git a/README.md b/README.md index 51fbf65..e3a9560 100644 --- a/README.md +++ b/README.md @@ -16,3 +16,9 @@ TODO: Fix all encoding / decoding to conform to ASN1 BER spec Implement Tests / Benchmarks + +--- + +The Go gopher was designed by Renee French. (http://reneefrench.blogspot.com/) +The design is licensed under the Creative Commons 3.0 Attributions license. +Read this article for more details: http://blog.golang.org/gopher diff --git a/ber.go b/ber.go index 0eb8219..25cc921 100644 --- a/ber.go +++ b/ber.go @@ -2,6 +2,7 @@ import ( "bytes" + "errors" "fmt" "io" "os" @@ -9,9 +10,7 @@ ) type Packet struct { - ClassType Class - TagType Type - Tag Tag + Identifier Value interface{} ByteValue []byte Data *bytes.Buffer @@ -19,7 +18,13 @@ Description string } -type Tag uint8 +type Identifier struct { + ClassType Class + TagType Type + Tag Tag +} + +type Tag uint64 const ( TagEOC Tag = 0x00 @@ -52,6 +57,23 @@ TagCharacterString Tag = 0x1d TagBMPString Tag = 0x1e TagBitmask Tag = 0x1f // xxx11111b + + // HighTag indicates the start of a high-tag byte sequence + HighTag Tag = 0x1f // xxx11111b + // HighTagContinueBitmask indicates the high-tag byte sequence should continue + HighTagContinueBitmask Tag = 0x80 // 10000000b + // HighTagValueBitmask obtains the tag value from a high-tag byte sequence byte + HighTagValueBitmask Tag = 0x7f // 01111111b +) + +const ( + // LengthLongFormBitmask is the mask to apply to the length byte to see if a long-form byte sequence is used + LengthLongFormBitmask = 0x80 + // LengthValueBitmask is the mask to apply to the length byte to get the number of bytes in the long-form byte sequence + LengthValueBitmask = 0x7f + + // LengthIndefinite is returned from readLength to indicate an indefinite length + LengthIndefinite = -1 ) var tagMap = map[Tag]string{ @@ -172,87 +194,12 @@ } } -func resizeBuffer(in []byte, new_size int) (out []byte) { - out = make([]byte, new_size) - - copy(out, in) - - return -} - +// ReadPacket reads a single Packet from the reader func ReadPacket(reader io.Reader) (*Packet, error) { - var header [2]byte - buf := header[:] - _, err := io.ReadFull(reader, buf) - + p, _, err := readPacket(reader) if err != nil { return nil, err } - - idx := 2 - var datalen int - l := buf[1] - - if l&0x80 == 0 { - // The length is encoded in the bottom 7 bits. - datalen = int(l & 0x7f) - if Debug { - fmt.Printf("Read: datalen = %d len(buf) = %d\n ", l, len(buf)) - - for _, b := range buf { - fmt.Printf("%02X ", b) - } - - fmt.Printf("\n") - } - } else { - // Bottom 7 bits give the number of length bytes to follow. - numBytes := int(l & 0x7f) - if numBytes == 0 { - return nil, fmt.Errorf("invalid length found") - } - idx += numBytes - buf = resizeBuffer(buf, 2+numBytes) - _, err := io.ReadFull(reader, buf[2:]) - - if err != nil { - return nil, err - } - datalen = 0 - for i := 0; i < numBytes; i++ { - b := buf[2+i] - datalen <<= 8 - datalen |= int(b) - } - - if Debug { - fmt.Printf("Read: datalen = %d numbytes=%d len(buf) = %d\n ", datalen, numBytes, len(buf)) - - for _, b := range buf { - fmt.Printf("%02X ", b) - } - - fmt.Printf("\n") - } - } - - buf = resizeBuffer(buf, idx+datalen) - _, err = io.ReadFull(reader, buf[idx:]) - - if err != nil { - return nil, err - } - - if Debug { - fmt.Printf("Read: len( buf ) = %d idx=%d datalen=%d idx+datalen=%d\n ", len(buf), idx, datalen, idx+datalen) - - for _, b := range buf { - fmt.Printf("%02X ", b) - } - } - - p, _ := decodePacket(buf) - return p, nil } @@ -306,92 +253,129 @@ return } +// DecodePacket decodes the given bytes into a single Packet +// If a decode error is encountered, nil is returned. func DecodePacket(data []byte) *Packet { - p, _ := decodePacket(data) + p, _, _ := readPacket(bytes.NewBuffer(data)) return p } -func decodePacket(data []byte) (*Packet, []byte) { - if Debug { - fmt.Printf("decodePacket: enter %d\n", len(data)) - } - - p := new(Packet) - - p.ClassType = Class(data[0]) & ClassBitmask - p.TagType = Type(data[0]) & TypeBitmask - p.Tag = Tag(data[0]) & TagBitmask - - var datalen int - l := data[1] - datapos := 2 - if l&0x80 == 0 { - // The length is encoded in the bottom 7 bits. - datalen = int(l & 0x7f) - } else { - // Bottom 7 bits give the number of length bytes to follow. - numBytes := int(l & 0x7f) - if numBytes == 0 { - return nil, nil - } - datapos += numBytes - datalen = 0 - for i := 0; i < numBytes; i++ { - b := data[2+i] - datalen <<= 8 - datalen |= int(b) - } +// DecodePacketErr decodes the given bytes into a single Packet +// If a decode error is encountered, nil is returned +func DecodePacketErr(data []byte) (*Packet, error) { + p, _, err := readPacket(bytes.NewBuffer(data)) + if err != nil { + return nil, err + } + return p, nil +} + +// readPacket reads a single Packet from the reader, returning the number of bytes read +func readPacket(reader io.Reader) (*Packet, int, error) { + identifier, length, read, err := readHeader(reader) + if err != nil { + return nil, read, err + } + + p := &Packet{ + Identifier: identifier, } p.Data = new(bytes.Buffer) - p.Children = make([]*Packet, 0, 2) - p.Value = nil - value_data := data[datapos : datapos+datalen] - if p.TagType == TypeConstructed { - for len(value_data) != 0 { - var child *Packet - - child, value_data = decodePacket(value_data) + // TODO: if universal, ensure tag type is allowed to be constructed + + // Track how much content we've read + contentRead := 0 + for { + if length != LengthIndefinite { + // End if we've read what we've been told to + if contentRead == length { + break + } + // Detect if a packet boundary didn't fall on the expected length + if contentRead > length { + return nil, read, fmt.Errorf("expected to read %d bytes, read %d", length, contentRead) + } + } + + // Read the next packet + child, r, err := readPacket(reader) + if err != nil { + return nil, read, err + } + contentRead += r + read += r + + // Test is this is the EOC marker for our packet + if isEOCPacket(child) { + if length == LengthIndefinite { + break + } + return nil, read, errors.New("eoc child not allowed with definite length") + } + + // Append and continue p.AppendChild(child) } - } else if p.ClassType == ClassUniversal { - p.Data.Write(data[datapos : datapos+datalen]) - p.ByteValue = value_data + return p, read, nil + } + + if length == LengthIndefinite { + return nil, read, errors.New("indefinite length used with primitive type") + } + + // Read definite-length content + content := make([]byte, length, length) + if length > 0 { + _, err := io.ReadFull(reader, content) + if err != nil { + if err == io.EOF { + return nil, read, io.ErrUnexpectedEOF + } + return nil, read, err + } + read += length + } + + if p.ClassType == ClassUniversal { + p.Data.Write(content) + p.ByteValue = content switch p.Tag { case TagEOC: case TagBoolean: - val, _ := parseInt64(value_data) + val, _ := parseInt64(content) p.Value = val != 0 case TagInteger: - p.Value, _ = parseInt64(value_data) + p.Value, _ = parseInt64(content) case TagBitString: case TagOctetString: // the actual string encoding is not known here - // (e.g. for LDAP value_data is already an UTF8-encoded + // (e.g. for LDAP content is already an UTF8-encoded // string). Return the data without further processing - p.Value = DecodeString(value_data) + p.Value = DecodeString(content) case TagNULL: case TagObjectIdentifier: case TagObjectDescriptor: case TagExternal: case TagRealFloat: case TagEnumerated: - p.Value, _ = parseInt64(value_data) + p.Value, _ = parseInt64(content) case TagEmbeddedPDV: case TagUTF8String: + p.Value = DecodeString(content) case TagRelativeOID: case TagSequence: case TagSet: case TagNumericString: case TagPrintableString: - p.Value = DecodeString(value_data) + p.Value = DecodeString(content) case TagT61String: case TagVideotexString: case TagIA5String: @@ -405,25 +389,17 @@ case TagBMPString: } } else { - p.Data.Write(data[datapos : datapos+datalen]) - } - - return p, data[datapos+datalen:] + p.Data.Write(content) + } + + return p, read, nil } func (p *Packet) Bytes() []byte { var out bytes.Buffer - out.Write([]byte{byte(p.ClassType) | byte(p.TagType) | byte(p.Tag)}) - packet_length := encodeInteger(int64(p.Data.Len())) - - if p.Data.Len() > 127 || len(packet_length) > 1 { - out.Write([]byte{byte(len(packet_length) | 128)}) - out.Write(packet_length) - } else { - out.Write(packet_length) - } - + out.Write(encodeIdentifier(p.Identifier)) + out.Write(encodeLength(p.Data.Len())) out.Write(p.Data.Bytes()) return out.Bytes() diff --git a/ber_test.go b/ber_test.go index ccf4906..bbd22db 100644 --- a/ber_test.go +++ b/ber_test.go @@ -2,13 +2,14 @@ import ( "bytes" + "math" "io" "testing" ) func TestEncodeDecodeInteger(t *testing.T) { - for _, v := range []int64{0, 10, 128, 1024, -1, -100, -128, -1024} { + for _, v := range []int64{0, 10, 128, 1024, math.MaxInt64, -1, -100, -128, -1024, math.MinInt64} { enc := encodeInteger(v) dec, err := parseInt64(enc) if err != nil { @@ -89,26 +90,33 @@ func TestSequenceAndAppendChild(t *testing.T) { - p1 := NewString(ClassUniversal, TypePrimitive, TagOctetString, "HIC SVNT LEONES", "String") - p2 := NewString(ClassUniversal, TypePrimitive, TagOctetString, "HIC SVNT DRACONES", "String") - p3 := NewString(ClassUniversal, TypePrimitive, TagOctetString, "Terra Incognita", "String") + values := []string{ + "HIC SVNT LEONES", + "Iñtërnâtiônàlizætiøn", + "Terra Incognita", + } sequence := NewSequence("a sequence") - sequence.AppendChild(p1) - sequence.AppendChild(p2) - sequence.AppendChild(p3) + for _, s := range values { + sequence.AppendChild(NewString(ClassUniversal, TypePrimitive, TagOctetString, s, "String")) + } - if len(sequence.Children) != 3 { - t.Error("wrong length for children array should be three =>", len(sequence.Children)) + if len(sequence.Children) != len(values) { + t.Errorf("wrong length for children array should be %d, got %d", len(values), len(sequence.Children)) } encodedSequence := sequence.Bytes() decodedSequence := DecodePacket(encodedSequence) - if len(decodedSequence.Children) != 3 { - t.Error("wrong length for children array should be three =>", len(decodedSequence.Children)) + if len(decodedSequence.Children) != len(values) { + t.Errorf("wrong length for children array should be %d => %d", len(values), len(decodedSequence.Children)) } + for i, s := range values { + if decodedSequence.Children[i].Value.(string) != s { + t.Errorf("expected %d to be %q, got %q", i, s, decodedSequence.Children[i].Value.(string)) + } + } } func TestReadPacket(t *testing.T) { @@ -140,6 +148,8 @@ {v: 256, e: []byte{0x02, 0x02, 0x01, 0x00}}, {v: -128, e: []byte{0x02, 0x01, 0x80}}, {v: -129, e: []byte{0x02, 0x02, 0xFF, 0x7F}}, + {v: math.MaxInt64, e: []byte{0x02, 0x08, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}}, + {v: math.MinInt64, e: []byte{0x02, 0x08, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, } for _, d := range data { diff --git a/content_int.go b/content_int.go new file mode 100644 index 0000000..1858b74 --- /dev/null +++ b/content_int.go @@ -0,0 +1,25 @@ +package ber + +func encodeUnsignedInteger(i uint64) []byte { + n := uint64Length(i) + out := make([]byte, n) + + var j int + for ; n > 0; n-- { + out[j] = (byte(i >> uint((n-1)*8))) + j++ + } + + return out +} + +func uint64Length(i uint64) (numBytes int) { + numBytes = 1 + + for i > 255 { + numBytes++ + i >>= 8 + } + + return +} diff --git a/header.go b/header.go new file mode 100644 index 0000000..123744e --- /dev/null +++ b/header.go @@ -0,0 +1,29 @@ +package ber + +import ( + "errors" + "io" +) + +func readHeader(reader io.Reader) (identifier Identifier, length int, read int, err error) { + if i, c, err := readIdentifier(reader); err != nil { + return Identifier{}, 0, read, err + } else { + identifier = i + read += c + } + + if l, c, err := readLength(reader); err != nil { + return Identifier{}, 0, read, err + } else { + length = l + read += c + } + + // Validate length type with identifier (x.600, 8.1.3.2.a) + if length == LengthIndefinite && identifier.TagType == TypePrimitive { + return Identifier{}, 0, read, errors.New("indefinite length used with primitive type") + } + + return identifier, length, read, nil +} diff --git a/header_test.go b/header_test.go new file mode 100644 index 0000000..cac1e2e --- /dev/null +++ b/header_test.go @@ -0,0 +1,135 @@ +package ber + +import ( + "bytes" + "io" + "testing" +) + +func TestReadHeader(t *testing.T) { + testcases := map[string]struct { + Data []byte + ExpectedIdentifier Identifier + ExpectedLength int + ExpectedBytesRead int + ExpectedError string + }{ + "empty": { + Data: []byte{}, + ExpectedIdentifier: Identifier{}, + ExpectedLength: 0, + ExpectedBytesRead: 0, + ExpectedError: io.ErrUnexpectedEOF.Error(), + }, + + "valid short form": { + Data: []byte{ + byte(ClassUniversal) | byte(TypePrimitive) | byte(TagCharacterString), + 127, + }, + ExpectedIdentifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypePrimitive, + Tag: TagCharacterString, + }, + ExpectedLength: 127, + ExpectedBytesRead: 2, + ExpectedError: "", + }, + + "valid long form": { + Data: []byte{ + // 2-byte encoding of tag + byte(ClassUniversal) | byte(TypePrimitive) | byte(HighTag), + byte(TagCharacterString), + + // 2-byte encoding of length + LengthLongFormBitmask | 1, + 127, + }, + ExpectedIdentifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypePrimitive, + Tag: TagCharacterString, + }, + ExpectedLength: 127, + ExpectedBytesRead: 4, + ExpectedError: "", + }, + + "valid indefinite length": { + Data: []byte{ + byte(ClassUniversal) | byte(TypeConstructed) | byte(TagCharacterString), + LengthLongFormBitmask, + }, + ExpectedIdentifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypeConstructed, + Tag: TagCharacterString, + }, + ExpectedLength: LengthIndefinite, + ExpectedBytesRead: 2, + ExpectedError: "", + }, + + "invalid indefinite length": { + Data: []byte{ + byte(ClassUniversal) | byte(TypePrimitive) | byte(TagCharacterString), + LengthLongFormBitmask, + }, + ExpectedIdentifier: Identifier{}, + ExpectedLength: 0, + ExpectedBytesRead: 2, + ExpectedError: "indefinite length used with primitive type", + }, + } + + for k, tc := range testcases { + reader := bytes.NewBuffer(tc.Data) + identifier, length, read, err := readHeader(reader) + + if err != nil { + if tc.ExpectedError == "" { + t.Errorf("%s: unexpected error: %v", k, err) + } else if err.Error() != tc.ExpectedError { + t.Errorf("%s: expected error %v, got %v", k, tc.ExpectedError, err) + } + } else if tc.ExpectedError != "" { + t.Errorf("%s: expected error %v, got none", k, tc.ExpectedError) + continue + } + + if read != tc.ExpectedBytesRead { + t.Errorf("%s: expected read %d, got %d", k, tc.ExpectedBytesRead, read) + } + + if identifier.ClassType != tc.ExpectedIdentifier.ClassType { + t.Errorf("%s: expected class type %d (%s), got %d (%s)", k, + tc.ExpectedIdentifier.ClassType, + ClassMap[tc.ExpectedIdentifier.ClassType], + identifier.ClassType, + ClassMap[identifier.ClassType], + ) + } + if identifier.TagType != tc.ExpectedIdentifier.TagType { + t.Errorf("%s: expected tag type %d (%s), got %d (%s)", k, + tc.ExpectedIdentifier.TagType, + TypeMap[tc.ExpectedIdentifier.TagType], + identifier.TagType, + TypeMap[identifier.TagType], + ) + } + if identifier.Tag != tc.ExpectedIdentifier.Tag { + t.Errorf("%s: expected tag %d (%s), got %d (%s)", k, + tc.ExpectedIdentifier.Tag, + tagMap[tc.ExpectedIdentifier.Tag], + identifier.Tag, + tagMap[identifier.Tag], + ) + } + + if length != tc.ExpectedLength { + t.Errorf("%s: expected length %d, got %d", k, tc.ExpectedLength, length) + } + } +} diff --git a/identifier.go b/identifier.go new file mode 100644 index 0000000..f7672a8 --- /dev/null +++ b/identifier.go @@ -0,0 +1,103 @@ +package ber + +import ( + "errors" + "fmt" + "io" + "math" +) + +func readIdentifier(reader io.Reader) (Identifier, int, error) { + identifier := Identifier{} + read := 0 + + // identifier byte + b, err := readByte(reader) + if err != nil { + if Debug { + fmt.Printf("error reading identifier byte: %v\n", err) + } + return Identifier{}, read, err + } + read++ + + identifier.ClassType = Class(b) & ClassBitmask + identifier.TagType = Type(b) & TypeBitmask + + if tag := Tag(b) & TagBitmask; tag != HighTag { + // short-form tag + identifier.Tag = tag + return identifier, read, nil + } + + // high-tag-number tag + tagBytes := 0 + for { + b, err := readByte(reader) + if err != nil { + if Debug { + fmt.Printf("error reading high-tag-number tag byte %d: %v\n", tagBytes, err) + } + return Identifier{}, read, err + } + tagBytes++ + read++ + + // Lowest 7 bits get appended to the tag value (x.690, 8.1.2.4.2.b) + identifier.Tag <<= 7 + identifier.Tag |= Tag(b) & HighTagValueBitmask + + // First byte may not be all zeros (x.690, 8.1.2.4.2.c) + if tagBytes == 1 && identifier.Tag == 0 { + return Identifier{}, read, errors.New("invalid first high-tag-number tag byte") + } + // Overflow of int64 + // TODO: support big int tags? + if tagBytes > 9 { + return Identifier{}, read, errors.New("high-tag-number tag overflow") + } + + // Top bit of 0 means this is the last byte in the high-tag-number tag (x.690, 8.1.2.4.2.a) + if Tag(b)&HighTagContinueBitmask == 0 { + break + } + } + + return identifier, read, nil +} + +func encodeIdentifier(identifier Identifier) []byte { + b := []byte{0x0} + b[0] |= byte(identifier.ClassType) + b[0] |= byte(identifier.TagType) + + if identifier.Tag < HighTag { + // Short-form + b[0] |= byte(identifier.Tag) + } else { + // high-tag-number + b[0] |= byte(HighTag) + + tag := identifier.Tag + + highBit := uint(63) + for { + if tag&(1<= 0; i-- { + offset := uint(i) * 7 + mask := Tag(0x7f) << offset + tagByte := (tag & mask) >> offset + if i != 0 { + tagByte |= 0x80 + } + b = append(b, byte(tagByte)) + } + } + return b +} diff --git a/identifier_test.go b/identifier_test.go new file mode 100644 index 0000000..7169362 --- /dev/null +++ b/identifier_test.go @@ -0,0 +1,344 @@ +package ber + +import ( + "bytes" + "io" + "math" + "testing" +) + +func TestReadIdentifier(t *testing.T) { + testcases := map[string]struct { + Data []byte + + ExpectedIdentifier Identifier + ExpectedBytesRead int + ExpectedError string + }{ + "empty": { + Data: []byte{}, + ExpectedBytesRead: 0, + ExpectedError: io.ErrUnexpectedEOF.Error(), + }, + + "universal primitive eoc": { + Data: []byte{byte(ClassUniversal) | byte(TypePrimitive) | byte(TagEOC)}, + ExpectedIdentifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypePrimitive, + Tag: TagEOC, + }, + ExpectedBytesRead: 1, + }, + "universal primitive character string": { + Data: []byte{byte(ClassUniversal) | byte(TypePrimitive) | byte(TagCharacterString)}, + ExpectedIdentifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypePrimitive, + Tag: TagCharacterString, + }, + ExpectedBytesRead: 1, + }, + + "universal constructed bit string": { + Data: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(TagBitString)}, + ExpectedIdentifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypeConstructed, + Tag: TagBitString, + }, + ExpectedBytesRead: 1, + }, + "universal constructed character string": { + Data: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(TagCharacterString)}, + ExpectedIdentifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypeConstructed, + Tag: TagCharacterString, + }, + ExpectedBytesRead: 1, + }, + + "application constructed object descriptor": { + Data: []byte{byte(ClassApplication) | byte(TypeConstructed) | byte(TagObjectDescriptor)}, + ExpectedIdentifier: Identifier{ + ClassType: ClassApplication, + TagType: TypeConstructed, + Tag: TagObjectDescriptor, + }, + ExpectedBytesRead: 1, + }, + "context constructed object descriptor": { + Data: []byte{byte(ClassContext) | byte(TypeConstructed) | byte(TagObjectDescriptor)}, + ExpectedIdentifier: Identifier{ + ClassType: ClassContext, + TagType: TypeConstructed, + Tag: TagObjectDescriptor, + }, + ExpectedBytesRead: 1, + }, + "private constructed object descriptor": { + Data: []byte{byte(ClassPrivate) | byte(TypeConstructed) | byte(TagObjectDescriptor)}, + ExpectedIdentifier: Identifier{ + ClassType: ClassPrivate, + TagType: TypeConstructed, + Tag: TagObjectDescriptor, + }, + ExpectedBytesRead: 1, + }, + + "high-tag-number tag missing bytes": { + Data: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag)}, + ExpectedError: io.ErrUnexpectedEOF.Error(), + ExpectedBytesRead: 1, + }, + "high-tag-number tag invalid first byte": { + Data: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), 0x0}, + ExpectedError: "invalid first high-tag-number tag byte", + ExpectedBytesRead: 2, + }, + "high-tag-number tag invalid first byte with continue bit": { + Data: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), byte(HighTagContinueBitmask)}, + ExpectedError: "invalid first high-tag-number tag byte", + ExpectedBytesRead: 2, + }, + "high-tag-number tag continuation missing bytes": { + Data: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), byte(HighTagContinueBitmask | 0x1)}, + ExpectedError: io.ErrUnexpectedEOF.Error(), + ExpectedBytesRead: 2, + }, + "high-tag-number tag overflow": { + Data: []byte{ + byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), + byte(HighTagContinueBitmask | 0x1), + byte(HighTagContinueBitmask | 0x1), + byte(HighTagContinueBitmask | 0x1), + byte(HighTagContinueBitmask | 0x1), + byte(HighTagContinueBitmask | 0x1), + byte(HighTagContinueBitmask | 0x1), + byte(HighTagContinueBitmask | 0x1), + byte(HighTagContinueBitmask | 0x1), + byte(HighTagContinueBitmask | 0x1), + byte(0x1), + }, + ExpectedError: "high-tag-number tag overflow", + ExpectedBytesRead: 11, + }, + "max high-tag-number tag": { + Data: []byte{ + byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(0x7f), + }, + ExpectedIdentifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypeConstructed, + Tag: Tag(0x7FFFFFFFFFFFFFFF), // 01111111...(63)...11111b + }, + ExpectedBytesRead: 10, + }, + "high-tag-number encoding of low-tag value": { + Data: []byte{ + byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), + byte(TagObjectDescriptor), + }, + ExpectedIdentifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypeConstructed, + Tag: TagObjectDescriptor, + }, + ExpectedBytesRead: 2, + }, + "max high-tag-number tag ignores extra data": { + Data: []byte{ + byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(0x7f), + byte(0x01), // extra data, shouldn't be read + byte(0x02), // extra data, shouldn't be read + byte(0x03), // extra data, shouldn't be read + }, + ExpectedIdentifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypeConstructed, + Tag: Tag(0x7FFFFFFFFFFFFFFF), // 01111111...(63)...11111b + }, + ExpectedBytesRead: 10, + }, + } + + for k, tc := range testcases { + reader := bytes.NewBuffer(tc.Data) + identifier, read, err := readIdentifier(reader) + + if err != nil { + if tc.ExpectedError == "" { + t.Errorf("%s: unexpected error: %v", k, err) + } else if err.Error() != tc.ExpectedError { + t.Errorf("%s: expected error %v, got %v", k, tc.ExpectedError, err) + } + } else if tc.ExpectedError != "" { + t.Errorf("%s: expected error %v, got none", k, tc.ExpectedError) + continue + } + + if read != tc.ExpectedBytesRead { + t.Errorf("%s: expected read %d, got %d", k, tc.ExpectedBytesRead, read) + } + + if identifier.ClassType != tc.ExpectedIdentifier.ClassType { + t.Errorf("%s: expected class type %d (%s), got %d (%s)", k, + tc.ExpectedIdentifier.ClassType, + ClassMap[tc.ExpectedIdentifier.ClassType], + identifier.ClassType, + ClassMap[identifier.ClassType], + ) + } + if identifier.TagType != tc.ExpectedIdentifier.TagType { + t.Errorf("%s: expected tag type %d (%s), got %d (%s)", k, + tc.ExpectedIdentifier.TagType, + TypeMap[tc.ExpectedIdentifier.TagType], + identifier.TagType, + TypeMap[identifier.TagType], + ) + } + if identifier.Tag != tc.ExpectedIdentifier.Tag { + t.Errorf("%s: expected tag %d (%s), got %d (%s)", k, + tc.ExpectedIdentifier.Tag, + tagMap[tc.ExpectedIdentifier.Tag], + identifier.Tag, + tagMap[identifier.Tag], + ) + } + } +} + +func TestEncodeIdentifier(t *testing.T) { + testcases := map[string]struct { + Identifier Identifier + ExpectedBytes []byte + }{ + "universal primitive eoc": { + Identifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypePrimitive, + Tag: TagEOC, + }, + ExpectedBytes: []byte{byte(ClassUniversal) | byte(TypePrimitive) | byte(TagEOC)}, + }, + "universal primitive character string": { + Identifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypePrimitive, + Tag: TagCharacterString, + }, + ExpectedBytes: []byte{byte(ClassUniversal) | byte(TypePrimitive) | byte(TagCharacterString)}, + }, + + "universal constructed bit string": { + Identifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypeConstructed, + Tag: TagBitString, + }, + ExpectedBytes: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(TagBitString)}, + }, + "universal constructed character string": { + Identifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypeConstructed, + Tag: TagCharacterString, + }, + ExpectedBytes: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(TagCharacterString)}, + }, + + "application constructed object descriptor": { + Identifier: Identifier{ + ClassType: ClassApplication, + TagType: TypeConstructed, + Tag: TagObjectDescriptor, + }, + ExpectedBytes: []byte{byte(ClassApplication) | byte(TypeConstructed) | byte(TagObjectDescriptor)}, + }, + "context constructed object descriptor": { + Identifier: Identifier{ + ClassType: ClassContext, + TagType: TypeConstructed, + Tag: TagObjectDescriptor, + }, + ExpectedBytes: []byte{byte(ClassContext) | byte(TypeConstructed) | byte(TagObjectDescriptor)}, + }, + "private constructed object descriptor": { + Identifier: Identifier{ + ClassType: ClassPrivate, + TagType: TypeConstructed, + Tag: TagObjectDescriptor, + }, + ExpectedBytes: []byte{byte(ClassPrivate) | byte(TypeConstructed) | byte(TagObjectDescriptor)}, + }, + + "max low-tag-number tag": { + Identifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypeConstructed, + Tag: TagBMPString, + }, + ExpectedBytes: []byte{ + byte(ClassUniversal) | byte(TypeConstructed) | byte(TagBMPString), + }, + }, + + "min high-tag-number tag": { + Identifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypeConstructed, + Tag: TagBMPString + 1, + }, + ExpectedBytes: []byte{ + byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), + byte(TagBMPString + 1), + }, + }, + + "max high-tag-number tag": { + Identifier: Identifier{ + ClassType: ClassUniversal, + TagType: TypeConstructed, + Tag: Tag(math.MaxInt64), + }, + ExpectedBytes: []byte{ + byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(HighTagContinueBitmask | 0x7f), + byte(0x7f), + }, + }, + } + + for k, tc := range testcases { + b := encodeIdentifier(tc.Identifier) + if bytes.Compare(tc.ExpectedBytes, b) != 0 { + t.Errorf("%s: Expected\n\t%#v\ngot\n\t%#v", k, tc.ExpectedBytes, b) + } + } +} diff --git a/length.go b/length.go new file mode 100644 index 0000000..8e2ae4d --- /dev/null +++ b/length.go @@ -0,0 +1,71 @@ +package ber + +import ( + "errors" + "fmt" + "io" +) + +func readLength(reader io.Reader) (length int, read int, err error) { + // length byte + b, err := readByte(reader) + if err != nil { + if Debug { + fmt.Printf("error reading length byte: %v\n", err) + } + return 0, 0, err + } + read++ + + switch { + case b == 0xFF: + // Invalid 0xFF (x.600, 8.1.3.5.c) + return 0, read, errors.New("invalid length byte 0xff") + + case b == LengthLongFormBitmask: + // Indefinite form, we have to decode packets until we encounter an EOC packet (x.600, 8.1.3.6) + length = LengthIndefinite + + case b&LengthLongFormBitmask == 0: + // Short definite form, extract the length from the bottom 7 bits (x.600, 8.1.3.4) + length = int(b) & LengthValueBitmask + + case b&LengthLongFormBitmask != 0: + // Long definite form, extract the number of length bytes to follow from the bottom 7 bits (x.600, 8.1.3.5.b) + lengthBytes := int(b) & LengthValueBitmask + // Protect against overflow + // TODO: support big int length? + if lengthBytes > 8 { + return 0, read, errors.New("long-form length overflow") + } + for i := 0; i < lengthBytes; i++ { + b, err = readByte(reader) + if err != nil { + if Debug { + fmt.Printf("error reading long-form length byte %d: %v\n", i, err) + } + return 0, read, err + } + read++ + + // x.600, 8.1.3.5 + length <<= 8 + length |= int(b) + } + + default: + return 0, read, errors.New("invalid length byte") + } + + return length, read, nil +} + +func encodeLength(length int) []byte { + length_bytes := encodeUnsignedInteger(uint64(length)) + if length > 127 || len(length_bytes) > 1 { + longFormBytes := []byte{(LengthLongFormBitmask | byte(len(length_bytes)))} + longFormBytes = append(longFormBytes, length_bytes...) + length_bytes = longFormBytes + } + return length_bytes +} diff --git a/length_test.go b/length_test.go new file mode 100644 index 0000000..afe0e80 --- /dev/null +++ b/length_test.go @@ -0,0 +1,158 @@ +package ber + +import ( + "bytes" + "io" + "math" + "testing" +) + +func TestReadLength(t *testing.T) { + testcases := map[string]struct { + Data []byte + + ExpectedLength int + ExpectedBytesRead int + ExpectedError string + }{ + "empty": { + Data: []byte{}, + ExpectedBytesRead: 0, + ExpectedError: io.ErrUnexpectedEOF.Error(), + }, + "invalid first byte": { + Data: []byte{0xFF}, + ExpectedBytesRead: 1, + ExpectedError: "invalid length byte 0xff", + }, + + "indefinite form": { + Data: []byte{LengthLongFormBitmask}, + ExpectedLength: LengthIndefinite, + ExpectedBytesRead: 1, + }, + + "short-definite-form zero length": { + Data: []byte{0}, + ExpectedLength: 0, + ExpectedBytesRead: 1, + }, + "short-definite-form length 1": { + Data: []byte{1}, + ExpectedLength: 1, + ExpectedBytesRead: 1, + }, + "short-definite-form max length": { + Data: []byte{127}, + ExpectedLength: 127, + ExpectedBytesRead: 1, + }, + + "long-definite-form missing bytes": { + Data: []byte{LengthLongFormBitmask | 1}, + ExpectedBytesRead: 1, + ExpectedError: io.ErrUnexpectedEOF.Error(), + }, + "long-definite-form overflow": { + Data: []byte{LengthLongFormBitmask | 9}, + ExpectedBytesRead: 1, + ExpectedError: "long-form length overflow", + }, + "long-definite-form zero length": { + Data: []byte{LengthLongFormBitmask | 1, 0x0}, + ExpectedLength: 0, + ExpectedBytesRead: 2, + }, + "long-definite-form length 127": { + Data: []byte{LengthLongFormBitmask | 1, 127}, + ExpectedLength: 127, + ExpectedBytesRead: 2, + }, + "long-definite-form max length": { + Data: []byte{ + LengthLongFormBitmask | 8, + 0x7F, + 0xFF, + 0xFF, + 0xFF, + 0xFF, + 0xFF, + 0xFF, + 0xFF, + }, + ExpectedLength: math.MaxInt64, + ExpectedBytesRead: 9, + }, + } + + for k, tc := range testcases { + reader := bytes.NewBuffer(tc.Data) + length, read, err := readLength(reader) + + if err != nil { + if tc.ExpectedError == "" { + t.Errorf("%s: unexpected error: %v", k, err) + } else if err.Error() != tc.ExpectedError { + t.Errorf("%s: expected error %v, got %v", k, tc.ExpectedError, err) + } + } else if tc.ExpectedError != "" { + t.Errorf("%s: expected error %v, got none", k, tc.ExpectedError) + continue + } + + if read != tc.ExpectedBytesRead { + t.Errorf("%s: expected read %d, got %d", k, tc.ExpectedBytesRead, read) + } + + if length != tc.ExpectedLength { + t.Errorf("%s: expected length %d, got %d", k, tc.ExpectedLength, length) + } + } +} + +func TestEncodeLength(t *testing.T) { + testcases := map[string]struct { + Length int + ExpectedBytes []byte + }{ + "0": { + Length: 0, + ExpectedBytes: []byte{0}, + }, + "1": { + Length: 1, + ExpectedBytes: []byte{1}, + }, + + "max short-form length": { + Length: 127, + ExpectedBytes: []byte{127}, + }, + "min long-form length": { + Length: 128, + ExpectedBytes: []byte{LengthLongFormBitmask | 1, 128}, + }, + + "max long-form length": { + Length: math.MaxInt64, + ExpectedBytes: []byte{ + LengthLongFormBitmask | 8, + 0x7F, + 0xFF, + 0xFF, + 0xFF, + 0xFF, + 0xFF, + 0xFF, + 0xFF, + }, + }, + } + + for k, tc := range testcases { + b := encodeLength(tc.Length) + if bytes.Compare(tc.ExpectedBytes, b) != 0 { + t.Errorf("%s: Expected\n\t%#v\ngot\n\t%#v", k, tc.ExpectedBytes, b) + } + } +} diff --git a/suite_test.go b/suite_test.go new file mode 100644 index 0000000..ace8e67 --- /dev/null +++ b/suite_test.go @@ -0,0 +1,182 @@ +package ber + +import ( + "bytes" + "io" + "io/ioutil" + "testing" +) + +var errEOF = io.ErrUnexpectedEOF.Error() + +// Tests from http://www.strozhevsky.com/free_docs/free_asn1_testsuite_descr.pdf +// Source files and descriptions at http://www.strozhevsky.com/free_docs/TEST_SUITE.zip +var testcases = []struct { + // File contains the path to the BER-encoded file + File string + // Error indicates whether a decoding error is expected + Error string + // AbnormalEncoding indicates whether a normalized re-encoding is expected to differ from the original source + AbnormalEncoding bool + // IndefiniteEncoding indicates the source file used indefinite-length encoding, so the re-encoding is expected to differ (since the length is known) + IndefiniteEncoding bool +}{ + // Common blocks + {File: "tests/tc1.ber", Error: "high-tag-number tag overflow"}, + {File: "tests/tc2.ber", Error: errEOF}, + {File: "tests/tc3.ber", Error: errEOF}, + {File: "tests/tc4.ber", Error: "invalid length byte 0xff"}, + {File: "tests/tc5.ber", Error: "", AbnormalEncoding: true}, + // Real numbers (some expected failures are disabled until support is added) + {File: "tests/tc6.ber", Error: ""}, // Error: "REAL value +0 must be encoded with zero-length value block"}, + {File: "tests/tc7.ber", Error: ""}, // Error: "REAL value -0 must be encoded as a special value"}, + {File: "tests/tc8.ber", Error: ""}, + {File: "tests/tc9.ber", Error: ""}, // Error: "Bits 6 and 5 of information octet for REAL are equal to 11" + {File: "tests/tc10.ber", Error: ""}, + {File: "tests/tc11.ber", Error: ""}, // Error: "Incorrect NR form" + {File: "tests/tc12.ber", Error: ""}, // Error: "Encoding of "special value" not from ASN.1 standard" + {File: "tests/tc13.ber", Error: errEOF}, + {File: "tests/tc14.ber", Error: errEOF}, + {File: "tests/tc15.ber", Error: ""}, // Error: "Too big value of exponent" + {File: "tests/tc16.ber", Error: ""}, // Error: "Too big value of mantissa" + {File: "tests/tc17.ber", Error: ""}, // Error: "Too big values for exponent and mantissa + using of "scaling factor" value" + // Integers + {File: "tests/tc18.ber", Error: ""}, + {File: "tests/tc19.ber", Error: errEOF}, + {File: "tests/tc20.ber", Error: ""}, + // Object identifiers + {File: "tests/tc21.ber", Error: ""}, + {File: "tests/tc22.ber", Error: ""}, + {File: "tests/tc23.ber", Error: errEOF}, + {File: "tests/tc24.ber", Error: ""}, + // Booleans + {File: "tests/tc25.ber", Error: ""}, + {File: "tests/tc26.ber", Error: ""}, + {File: "tests/tc27.ber", Error: errEOF}, + {File: "tests/tc28.ber", Error: ""}, + {File: "tests/tc29.ber", Error: ""}, + // Null + {File: "tests/tc30.ber", Error: ""}, + {File: "tests/tc31.ber", Error: errEOF}, + {File: "tests/tc32.ber", Error: ""}, + // Bitstring (some expected failures are disabled until support is added) + {File: "tests/tc33.ber", Error: ""}, // Error: "Too big value for "unused bits"" + {File: "tests/tc34.ber", Error: errEOF}, + {File: "tests/tc35.ber", Error: "", IndefiniteEncoding: true}, // Error: "Using of different from BIT STRING types as internal types for constructive encoding" + {File: "tests/tc36.ber", Error: "", IndefiniteEncoding: true}, // Error: "Using of "unused bits" in internal BIT STRINGs with constructive form of encoding" + {File: "tests/tc37.ber", Error: ""}, + {File: "tests/tc38.ber", Error: "", IndefiniteEncoding: true}, + {File: "tests/tc39.ber", Error: ""}, + {File: "tests/tc40.ber", Error: ""}, + // Octet string (some expected failures are disabled until support is added) + {File: "tests/tc41.ber", Error: "", IndefiniteEncoding: true}, // Error: "Using of different from OCTET STRING types as internal types for constructive encoding" + {File: "tests/tc42.ber", Error: errEOF}, + {File: "tests/tc43.ber", Error: errEOF}, + {File: "tests/tc44.ber", Error: ""}, + {File: "tests/tc45.ber", Error: ""}, + // Bitstring + {File: "tests/tc46.ber", Error: "indefinite length used with primitive type"}, + {File: "tests/tc47.ber", Error: "eoc child not allowed with definite length"}, + {File: "tests/tc48.ber", Error: "", IndefiniteEncoding: true}, // Error: "Using of more than 7 "unused bits" in BIT STRING with constrictive encoding form" +} + +func TestSuiteDecodePacket(t *testing.T) { + // Debug = true + for _, tc := range testcases { + file := tc.File + + dataIn, err := ioutil.ReadFile(file) + if err != nil { + t.Errorf("%s: %v", file, err) + continue + } + + // fmt.Printf("%s: decode %d\n", file, len(dataIn)) + packet, err := DecodePacketErr(dataIn) + if err != nil { + if tc.Error == "" { + t.Errorf("%s: unexpected error during DecodePacket: %v", file, err) + } else if tc.Error != err.Error() { + t.Errorf("%s: expected error %q during DecodePacket, got %q", file, tc.Error, err) + } + continue + } + if tc.Error != "" { + t.Errorf("%s: expected error %q, got none", file, tc.Error) + continue + } + + dataOut := packet.Bytes() + if tc.AbnormalEncoding || tc.IndefiniteEncoding { + // Abnormal encodings and encodings that used indefinite length should re-encode differently + if bytes.Equal(dataOut, dataIn) { + t.Errorf("%s: data should have been re-encoded differently", file) + } + } else if !bytes.Equal(dataOut, dataIn) { + // Make sure the serialized data matches the source + t.Errorf("%s: data should be the same", file) + } + + packet, err = DecodePacketErr(dataOut) + if err != nil { + t.Errorf("%s: unexpected error: %v", file, err) + continue + } + + // Make sure the re-serialized data matches our original serialization + dataOut2 := packet.Bytes() + if !bytes.Equal(dataOut, dataOut2) { + t.Errorf("%s: data should be the same", file) + } + } +} + +func TestSuiteReadPacket(t *testing.T) { + for _, tc := range testcases { + file := tc.File + + dataIn, err := ioutil.ReadFile(file) + if err != nil { + t.Errorf("%s: %v", file, err) + continue + } + + buffer := bytes.NewBuffer(dataIn) + packet, err := ReadPacket(buffer) + if err != nil { + if tc.Error == "" { + t.Errorf("%s: unexpected error during ReadPacket: %v", file, err) + } else if tc.Error != err.Error() { + t.Errorf("%s: expected error %q during ReadPacket, got %q", file, tc.Error, err) + } + continue + } + if tc.Error != "" { + t.Errorf("%s: expected error %q, got none", file, tc.Error) + continue + } + + dataOut := packet.Bytes() + if tc.AbnormalEncoding || tc.IndefiniteEncoding { + // Abnormal encodings and encodings that used indefinite length should re-encode differently + if bytes.Equal(dataOut, dataIn) { + t.Errorf("%s: data should have been re-encoded differently", file) + } + } else if !bytes.Equal(dataOut, dataIn) { + // Make sure the serialized data matches the source + t.Errorf("%s: data should be the same", file) + } + + packet, err = DecodePacketErr(dataOut) + if err != nil { + t.Errorf("%s: unexpected error: %v", file, err) + continue + } + + // Make sure the re-serialized data matches our original serialization + dataOut2 := packet.Bytes() + if !bytes.Equal(dataOut, dataOut2) { + t.Errorf("%s: data should be the same", file) + } + } +} diff --git a/tests/tc1.ber b/tests/tc1.ber new file mode 100644 index 0000000..5c6ba1c --- /dev/null +++ b/tests/tc1.ber @@ -0,0 +1 @@ +@ \ No newline at end of file diff --git a/tests/tc10.ber b/tests/tc10.ber new file mode 100644 index 0000000..f733125 --- /dev/null +++ b/tests/tc10.ber @@ -0,0 +1 @@ +  \ No newline at end of file diff --git a/tests/tc11.ber b/tests/tc11.ber new file mode 100644 index 0000000..cc4a609 --- /dev/null +++ b/tests/tc11.ber @@ -0,0 +1 @@ +  015625 \ No newline at end of file diff --git a/tests/tc12.ber b/tests/tc12.ber new file mode 100644 index 0000000..dbb538d --- /dev/null +++ b/tests/tc12.ber @@ -0,0 +1 @@ + I \ No newline at end of file diff --git a/tests/tc13.ber b/tests/tc13.ber new file mode 100644 index 0000000..f4f438e Binary files /dev/null and b/tests/tc13.ber differ diff --git a/tests/tc14.ber b/tests/tc14.ber new file mode 100644 index 0000000..b6f2fd3 Binary files /dev/null and b/tests/tc14.ber differ diff --git a/tests/tc15.ber b/tests/tc15.ber new file mode 100644 index 0000000..3d6da67 --- /dev/null +++ b/tests/tc15.ber @@ -0,0 +1 @@ +  \ No newline at end of file diff --git a/tests/tc16.ber b/tests/tc16.ber new file mode 100644 index 0000000..68634f5 --- /dev/null +++ b/tests/tc16.ber @@ -0,0 +1 @@ +  \ No newline at end of file diff --git a/tests/tc17.ber b/tests/tc17.ber new file mode 100644 index 0000000..adb9e33 --- /dev/null +++ b/tests/tc17.ber @@ -0,0 +1 @@ +   \ No newline at end of file diff --git a/tests/tc18.ber b/tests/tc18.ber new file mode 100644 index 0000000..fb6843f --- /dev/null +++ b/tests/tc18.ber @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/tests/tc19.ber b/tests/tc19.ber new file mode 100644 index 0000000..03afaa5 --- /dev/null +++ b/tests/tc19.ber @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/tests/tc2.ber b/tests/tc2.ber new file mode 100644 index 0000000..7e78577 --- /dev/null +++ b/tests/tc2.ber @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/tests/tc20.ber b/tests/tc20.ber new file mode 100644 index 0000000..a976464 Binary files /dev/null and b/tests/tc20.ber differ diff --git a/tests/tc21.ber b/tests/tc21.ber new file mode 100644 index 0000000..d6c2f9a --- /dev/null +++ b/tests/tc21.ber @@ -0,0 +1 @@ +Q \ No newline at end of file diff --git a/tests/tc22.ber b/tests/tc22.ber new file mode 100644 index 0000000..d1d70af --- /dev/null +++ b/tests/tc22.ber @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/tests/tc23.ber b/tests/tc23.ber new file mode 100644 index 0000000..0e8d18f --- /dev/null +++ b/tests/tc23.ber @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/tests/tc24.ber b/tests/tc24.ber new file mode 100644 index 0000000..10565ae --- /dev/null +++ b/tests/tc24.ber @@ -0,0 +1 @@ +`HO Jc/ \ No newline at end of file diff --git a/tests/tc25.ber b/tests/tc25.ber new file mode 100644 index 0000000..1e11405 Binary files /dev/null and b/tests/tc25.ber differ diff --git a/tests/tc26.ber b/tests/tc26.ber new file mode 100644 index 0000000..d28653b Binary files /dev/null and b/tests/tc26.ber differ diff --git a/tests/tc27.ber b/tests/tc27.ber new file mode 100644 index 0000000..c8c7811 --- /dev/null +++ b/tests/tc27.ber @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/tests/tc28.ber b/tests/tc28.ber new file mode 100644 index 0000000..415fe23 --- /dev/null +++ b/tests/tc28.ber @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/tests/tc29.ber b/tests/tc29.ber new file mode 100644 index 0000000..4076f44 Binary files /dev/null and b/tests/tc29.ber differ diff --git a/tests/tc3.ber b/tests/tc3.ber new file mode 100644 index 0000000..c05c900 --- /dev/null +++ b/tests/tc3.ber @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/tests/tc30.ber b/tests/tc30.ber new file mode 100644 index 0000000..72bcf80 Binary files /dev/null and b/tests/tc30.ber differ diff --git a/tests/tc31.ber b/tests/tc31.ber new file mode 100644 index 0000000..1fcc4f2 Binary files /dev/null and b/tests/tc31.ber differ diff --git a/tests/tc32.ber b/tests/tc32.ber new file mode 100644 index 0000000..19b3e94 Binary files /dev/null and b/tests/tc32.ber differ diff --git a/tests/tc33.ber b/tests/tc33.ber new file mode 100644 index 0000000..6ea70c4 --- /dev/null +++ b/tests/tc33.ber @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/tests/tc34.ber b/tests/tc34.ber new file mode 100644 index 0000000..6133709 --- /dev/null +++ b/tests/tc34.ber @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/tests/tc35.ber b/tests/tc35.ber new file mode 100644 index 0000000..d27eb30 Binary files /dev/null and b/tests/tc35.ber differ diff --git a/tests/tc36.ber b/tests/tc36.ber new file mode 100644 index 0000000..e5baaea Binary files /dev/null and b/tests/tc36.ber differ diff --git a/tests/tc37.ber b/tests/tc37.ber new file mode 100644 index 0000000..d0b1cfb Binary files /dev/null and b/tests/tc37.ber differ diff --git a/tests/tc38.ber b/tests/tc38.ber new file mode 100644 index 0000000..090bce7 Binary files /dev/null and b/tests/tc38.ber differ diff --git a/tests/tc39.ber b/tests/tc39.ber new file mode 100644 index 0000000..d9d0119 Binary files /dev/null and b/tests/tc39.ber differ diff --git a/tests/tc4.ber b/tests/tc4.ber new file mode 100644 index 0000000..2b888ba --- /dev/null +++ b/tests/tc4.ber @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/tests/tc40.ber b/tests/tc40.ber new file mode 100644 index 0000000..15294a5 Binary files /dev/null and b/tests/tc40.ber differ diff --git a/tests/tc41.ber b/tests/tc41.ber new file mode 100644 index 0000000..276836b Binary files /dev/null and b/tests/tc41.ber differ diff --git a/tests/tc42.ber b/tests/tc42.ber new file mode 100644 index 0000000..21cbfd1 Binary files /dev/null and b/tests/tc42.ber differ diff --git a/tests/tc43.ber b/tests/tc43.ber new file mode 100644 index 0000000..98dbd74 --- /dev/null +++ b/tests/tc43.ber @@ -0,0 +1 @@ +$ \ No newline at end of file diff --git a/tests/tc44.ber b/tests/tc44.ber new file mode 100644 index 0000000..d825e1a Binary files /dev/null and b/tests/tc44.ber differ diff --git a/tests/tc45.ber b/tests/tc45.ber new file mode 100644 index 0000000..7b861b0 Binary files /dev/null and b/tests/tc45.ber differ diff --git a/tests/tc46.ber b/tests/tc46.ber new file mode 100644 index 0000000..e78deee Binary files /dev/null and b/tests/tc46.ber differ diff --git a/tests/tc47.ber b/tests/tc47.ber new file mode 100644 index 0000000..190bb86 Binary files /dev/null and b/tests/tc47.ber differ diff --git a/tests/tc48.ber b/tests/tc48.ber new file mode 100644 index 0000000..f7f111a Binary files /dev/null and b/tests/tc48.ber differ diff --git a/tests/tc5.ber b/tests/tc5.ber new file mode 100644 index 0000000..45e0a00 --- /dev/null +++ b/tests/tc5.ber @@ -0,0 +1 @@ +@ \ No newline at end of file diff --git a/tests/tc6.ber b/tests/tc6.ber new file mode 100644 index 0000000..cee1aaf --- /dev/null +++ b/tests/tc6.ber @@ -0,0 +1 @@ + +0.E-5 \ No newline at end of file diff --git a/tests/tc7.ber b/tests/tc7.ber new file mode 100644 index 0000000..d5ae685 --- /dev/null +++ b/tests/tc7.ber @@ -0,0 +1 @@ + -0.E-5 \ No newline at end of file diff --git a/tests/tc8.ber b/tests/tc8.ber new file mode 100644 index 0000000..cb32a09 Binary files /dev/null and b/tests/tc8.ber differ diff --git a/tests/tc9.ber b/tests/tc9.ber new file mode 100644 index 0000000..50b43a5 --- /dev/null +++ b/tests/tc9.ber @@ -0,0 +1 @@ +  \ No newline at end of file diff --git a/util.go b/util.go new file mode 100644 index 0000000..3e56b66 --- /dev/null +++ b/util.go @@ -0,0 +1,24 @@ +package ber + +import "io" + +func readByte(reader io.Reader) (byte, error) { + bytes := make([]byte, 1, 1) + _, err := io.ReadFull(reader, bytes) + if err != nil { + if err == io.EOF { + return 0, io.ErrUnexpectedEOF + } + return 0, err + } + return bytes[0], nil +} + +func isEOCPacket(p *Packet) bool { + return p != nil && + p.Tag == TagEOC && + p.ClassType == ClassUniversal && + p.TagType == TypePrimitive && + len(p.ByteValue) == 0 && + len(p.Children) == 0 +}