X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=document%2Fdocument.go;h=0ac99b66cb6a6269c2a2949fcbb04c716c11ae60;hb=726f6af292a7ec7a1698b6bec11ea0ee48bfd001;hp=c55061984532a3807577c536e5274ed05d223556;hpb=39cf1c10d9551c4af216e9b72094fbe4700371f1;p=epoint diff --git a/document/document.go b/document/document.go index c550619..0ac99b6 100644 --- a/document/document.go +++ b/document/document.go @@ -1,26 +1,47 @@ -package document - -// An epoint document is a clear signed utf-8 text of key-value pairs -// according to OpenPGP RFC 4880. The body contains a content-type -// MIME header so it can be used in OpenPGP/MIME RFC 3156 emails with -// the signature detached. The format of the key-value pairs are -// similar to MIME header fields. +// Package document implements epoint document parsing and creation. +// +// An epoint document is an OpenPGP (RFC 4880) clear signed +// utf-8 text of key-value pairs. +// The body contains a content-type MIME header so the document +// can be used in OpenPGP/MIME (RFC 3156) emails. +// The format of the key-value pairs are similar to MIME header +// fields: keys and values are separated by ": ", repeated keys +// are not allowed, long values can be split before a space. // // Example: // // -----BEGIN PGP SIGNED MESSAGE----- // Hash: SHA1 // -// Content-Type: text/plain.epoint.cert; charset=utf-8 +// Content-Type: text/plain.epoint.type; charset=utf-8 // // Key: Value1 // Another-Key: Value2 +// Last-Key: Long +// value that spans +// multiple lines // -----BEGIN PGP SIGNATURE----- +// // pgp signature // -----END PGP SIGNATURE----- +package document + +// TODO: error wrapper (so reporting to user or creating bounce cert is simple) +// TODO: optional fields: exact semantics ("" vs "-" vs nil) +// TODO: trailing space handling in ParseFields +// TODO: fields of notice (last notice, serial, failure notice,..) +// TODO: limits and cert type specific input validation +// TODO: fix Cert mess +// TODO: nonce is id, id is even number of hex digits +// TODO: denom, issuer from key (key representation: armor?) import ( "bytes" + "crypto" + "crypto/openpgp" + "crypto/openpgp/armor" + "crypto/openpgp/packet" + "crypto/sha1" "encoding/hex" "fmt" "reflect" @@ -29,462 +50,683 @@ import ( "time" ) -const ClearSignedHeader = "-----BEGIN PGP SIGNED MESSAGE-----\n" +// limits +const ( + MaxFields = 20 + MaxLineLength = 160 // 1 sha512 + 1 key (without \n) + MaxValueLength = 1300 // 20 sha256 space separated (without \n) + MaxNonceLength = 20 + MaxDenominationLength = 100 +) + +const ClearSignedHeader = "-----BEGIN PGP SIGNED MESSAGE-----" -// (non-standard) MIME subtype for epoint documents, see RFC 2045 and RFC 2046 +// MIME type for epoint documents, see RFC 4288 var ContentType = map[string]string{ - "cert": "text/plain.epoint.cert; charset=utf-8", - "draft": "text/plain.epoint.draft; charset=utf-8", + "Draft": "text/vnd.epoint.draft; charset=utf-8", + "Notice": "text/vnd.epoint.notice; charset=utf-8", + "DebitCert": "text/vnd.epoint.debit; charset=utf-8", + "CreditCert": "text/vnd.epoint.credit; charset=utf-8", + "BounceCert": "text/vnd.epoint.bounce; charset=utf-8", } // OpenPGP signed cleartext document representation -type ClearSigned struct { +type Signed struct { + // Sign and CleanSigned sets Hash for FormatSigned + // TODO: CreationDate Hash string - // Signed text (no dash escape, no trailing space) + // Signed text (no dash escape, no trailing space, \n new lines) Body []byte // Armored detached text signature of the Body - ArmoredSignature []byte + Signature []byte } -type Field struct { - Key string - Value string +// parsed epoint document +type Document struct { + Type string + Fields map[string]string + Order []string +} + +var fieldtype = map[string]string{ + "Amount": "int", + "Authorized-By": "id", + "Balance": "int", + "Beneficiary": "id", + "Date": "date", + "Debit-Cert": "id", + "Denomination": "text", + "Difference": "int", + "Draft": "id", + "Drawer": "id", + "Expiry-Date": "date", + "Holder": "id", + "Issuer": "id", + "Last-Cert": "id", + "Last-Credit-Serial": "int", + "Last-Debit-Serial": "int", + "Maturity-Date": "date", + "Nonce": "id", + "Notes": "text", + "References": "ids", + "Serial": "int", +} + +var fieldname = map[string]string{ + "AuthorizedBy": "Authorized-By", + "DebitCert": "Debit-Cert", + "ExpiryDate": "Expiry-Date", + "LastCert": "Last-Cert", + "LastCreditSerial": "Last-Credit-Serial", + "LastDebitSerial": "Last-Debit-Serial", + "MaturityDate": "Maturity-Date", } -// Draft document represents an obligation transfer order type Draft struct { - Drawer string `marshal:"id"` // ID of the payer (signer of the document) - Beneficiary string `marshal:"id"` // ID of the payee - Amount int64 // amount transfered + Drawer string + Beneficiary string + Amount int64 Denomination string - IssueDate int64 `marshal:"date" key:"Issue-Date"` - // Draft is bounced before this date - MaturityDate int64 `marshal:"date" key:"Maturity-Date"` - Notes string // Arbitrary text notes of the drawer - Nonce string // unique number - Server string `marshal:"id"` // ID of the server - Drawee string `marshal:"id"` // ID of the obligation issuer - // useful if more strict date of issue information is needed - //References []string -} - -// Obligation certificate after a transfer -// References previous certificate (if any) -// and the transfer related other documents + Issuer string + AuthorizedBy string + MaturityDate *int64 // optional + ExpiryDate *int64 // optional + Nonce string + Notes *string // optional +} + +type Notice struct { + Date int64 + AuthorizedBy string + Notes *string // optional + References []string // may be empty (startup notice) +} + type Cert struct { - Holder string `marshal:"id"` // ID of the creditor - Serial uint32 // serial number, number of certs of the holder - Date int64 `marshal:"date"` // date of issue - Balance int64 // current obligation value + IsDebit bool + Holder string + Serial int64 + Balance int64 Denomination string - Server string `marshal:"id"` // ID of the server - Issuer string `marshal:"id"` // ID of the obligation issuer (drawee?) - LastDebitSerial uint32 `key:"Last-Debit-Serial"` // serial of the last draft cert or 0 - LastCreditSerial uint32 `key:"Last-Credit-Serial"` // serial of the last credit cert or 0 - LastCert string `marshal:"id" key:"Last-Cert"` // ID of the previous cert if any - Difference int64 // difference from previous balance - Draft string `marshal:"id"` // draft ID related to the transfer - Drawer string `marshal:"id"` // ID of the drawer in the transaction - DrawerSerial uint32 `key:"Drawer-Serial"` // serial of the drawer's related debit cert - DrawerCert string `marshal:"id" key:"Drawer-Cert"` // ID of the drawer's related debit cert - Notes string // Arbitrary text notes of the server (signer) - References []string `marshal:"idlist"` // cert IDs for timestamping the system -} - -func DecodeClearSigned(s []byte) (c *ClearSigned, err error) { - hash, body, sig := split(s) - if len(sig) == 0 { - err = fmt.Errorf("DecodeClearSigned could parse the signed document") - return + Issuer string + Date int64 + Difference int64 + Draft string + Beneficiary *string // only in debit cert + Drawer *string // only in credit cert + DebitCert *string // only in credit cert + AuthorizedBy string + Notes *string // optional + LastDebitSerial int64 // 0 if none + LastCreditSerial int64 // 0 if none + LastCert *string // nil if serial == 1 + References []string +} + +type DebitCert struct { + Holder string + Serial int64 + Balance int64 + Denomination string + Issuer string + Date int64 + Difference int64 + Draft string + Beneficiary string + AuthorizedBy string + Notes *string // optional + LastDebitSerial int64 // 0 if none + LastCreditSerial int64 // 0 if none + LastCert *string // nil if serial == 1 + References []string +} + +type CreditCert struct { + Holder string + Serial int64 + Balance int64 + Denomination string + Issuer string + Date int64 + Difference int64 + Draft string + Drawer string + DebitCert string + AuthorizedBy string + Notes *string // optional + LastDebitSerial int64 // 0 if none + LastCreditSerial int64 // 0 if none + LastCert *string // ? if serial == 1 + References []string +} + +type BounceCert struct { + Drawer string + Draft string + LastCert *string // optional + Balance int64 // 0 if none + Date int64 + AuthorizedBy string + Notes *string // optional + References []string +} + +func ToCert(v interface{}) (cert *Cert, err error) { + cert = new(Cert) + switch x := v.(type) { + case *DebitCert: + cert.IsDebit = true + cert.Beneficiary = &x.Beneficiary + + cert.Holder = x.Holder + cert.Serial = x.Serial + cert.Balance = x.Balance + cert.Denomination = x.Denomination + cert.Issuer = x.Issuer + cert.Date = x.Date + cert.Difference = x.Difference + cert.Draft = x.Draft + cert.AuthorizedBy = x.AuthorizedBy + cert.Notes = x.Notes + cert.LastDebitSerial = x.LastDebitSerial + cert.LastCreditSerial = x.LastCreditSerial + cert.LastCert = x.LastCert + cert.References = x.References + + case *CreditCert: + cert.IsDebit = false + cert.Drawer = &x.Drawer + cert.DebitCert = &x.DebitCert + + cert.Holder = x.Holder + cert.Serial = x.Serial + cert.Balance = x.Balance + cert.Denomination = x.Denomination + cert.Issuer = x.Issuer + cert.Date = x.Date + cert.Difference = x.Difference + cert.Draft = x.Draft + cert.AuthorizedBy = x.AuthorizedBy + cert.Notes = x.Notes + cert.LastDebitSerial = x.LastDebitSerial + cert.LastCreditSerial = x.LastCreditSerial + cert.LastCert = x.LastCert + cert.References = x.References + default: + err = fmt.Errorf("ToCert: only debit or credit document can be converted to cert") } - c = &ClearSigned{string(hash), trimspace(dashunesc(body)), sig} return } -func EncodeClearSigned(c *ClearSigned) (data []byte, err error) { - s := ClearSignedHeader - if c.Hash != "" { - s += "Hash: " + c.Hash + "\n" +// sha1 sum of the (cleaned) document body as uppercase hex string +func Id(c *Signed) string { + h := sha1.New() + h.Write(c.Body) + return fmt.Sprintf("%040X", h.Sum()) +} + +// parse an epoint document without checking the signature and format details +func Parse(s []byte) (iv interface{}, c *Signed, err error) { + c, err = ParseSigned(s) + if err != nil { + return } - // TODO: check if space was trimmed from body before signature - s += "\n" - s += string(dashesc(c.Body)) - s += "\n" - s += string(c.ArmoredSignature) - data = []byte(s) + doc, err := ParseDocument(c.Body) + if err != nil { + return + } + iv, err = ParseStruct(doc) return } -func ParseFields(s []byte) (fields []Field, rest []byte, err error) { - rest = s - for len(rest) > 0 { - var line []byte - line, rest = getLine(rest) - // empty line after the parsed fields (consumed) - if len(line) == 0 { - break - } - i := bytes.Index(line, []byte(": ")) - if i < 0 { - err = fmt.Errorf("ParseFields: missing ': '\n") - break - } - fields = append(fields, Field{string(line[:i]), string(line[i+2:])}) +// format and sign an epoint document +func Format(iv interface{}, key *openpgp.Entity) (s []byte, c *Signed, err error) { + doc, err := FormatStruct(iv) + if err != nil { + return } + body, err := FormatDocument(doc) + if err != nil { + return + } + c, err = Sign(body, key) + if err != nil { + return + } + s, err = FormatSigned(c) return } -func ParseBody(s []byte) (doctype string, fields []Field, err error) { - // parse content type header first - fs, s, err := ParseFields(s) +// verify an epoint document, return the cleaned version as well +func Verify(c *Signed, key openpgp.KeyRing) (err error) { + msg := bytes.NewBuffer(c.Body) + sig := bytes.NewBuffer(c.Signature) + // TODO: verify signature + _, _ = msg, sig + // _, err = openpgp.CheckArmoredDetachedSignature(key, msg, sig) + return +} + +// sign body with given secret key +func Sign(body []byte, key *openpgp.Entity) (c *Signed, err error) { + c = new(Signed) + c.Hash = "SHA256" + c.Body = body + w := new(bytes.Buffer) + err = openpgp.ArmoredDetachSignText(w, key, bytes.NewBuffer(c.Body)) if err != nil { return } - if len(fs) != 1 || fs[0].Key != "Content-Type" { - return "", nil, fmt.Errorf("ParseBody: single Content-Type header was expected\n") - } - ctype := fs[0].Value - for k, v := range ContentType { - if ctype == v { - doctype = k - break + // close armored document with a \n + _, _ = w.Write([]byte{'\n'}) + c.Signature = w.Bytes() + return +} + +// split a clear signed document into body and armored signature +func ParseSigned(s []byte) (c *Signed, err error) { + // look for clear signed header + for !bytes.HasPrefix(s, []byte(ClearSignedHeader)) { + _, s = getLine(s) + if len(s) == 0 { + err = fmt.Errorf("ParseSigned: clear signed header is missing") + return } } - if doctype == "" { - return "", nil, fmt.Errorf("ParseBody: unknown Content-Type: %s", ctype) + s = s[len(ClearSignedHeader):] + // end of line after the header + empty, s := getLine(s) + if len(empty) != 0 { + err = fmt.Errorf("ParseSigned: bad clear signed header") + return + } + // skip all hash headers, section 7. + for bytes.HasPrefix(s, []byte("Hash: ")) { + _, s = getLine(s) } - fields, s, err = ParseFields(s) - if err == nil && len(s) > 0 { - err = fmt.Errorf("ParseBody: extra data after fields: %q", s) + // skip empty line + empty, s = getLine(s) + if len(empty) != 0 { + err = fmt.Errorf("ParseSigned: expected an empty line after armor headers") + return } + lines := [][]byte{} + for !bytes.HasPrefix(s, []byte("-----BEGIN")) { + var line []byte + line, s = getLine(s) + // dash unescape, section 7.1. + if bytes.HasPrefix(line, []byte("- ")) { + line = line[2:] + } + // empty values are not supported: "Key: \n" + lines = append(lines, bytes.TrimRight(line, " \t")) + } + c = new(Signed) + // last line is not closed by \n + c.Body = bytes.Join(lines, []byte("\n")) + // signature is just the rest of the input data + c.Signature = s return } -func parse(s []byte, doctype string) (v interface{}, err error) { - t, fields, err := ParseBody(s) +// clean up, check and reencode signature +// used on drafts before calculating the signed document hash +func CleanSigned(c *Signed) (err error) { + b, err := armor.Decode(bytes.NewBuffer(c.Signature)) if err != nil { return } - if doctype != t && doctype != "" { - err = fmt.Errorf("parse: expected doctype %s; got %s", doctype, t) + if b.Type != openpgp.SignatureType { + err = fmt.Errorf("CleanSigned: invalid armored signature type") return } - switch t { - case "draft": - v = new(Draft) - case "cert": - v = new(Cert) - default: - err = fmt.Errorf("parse: unkown doc type: %s", t) + p, err := packet.Read(b.Body) + if err != nil { return } - err = unmarshal(fields, v) - return -} - -// TODO: limit errors -func render(v interface{}) ([]byte, error) { - doctype := "" - switch v.(type) { - case *Draft: - doctype = "draft" - case *Cert: - doctype = "cert" + sig, ok := p.(*packet.Signature) + if !ok { + err = fmt.Errorf("CleanSigned: invalid signature packet") + return + } + // section 5.2.3 + if sig.SigType != packet.SigTypeText { + err = fmt.Errorf("CleanSigned: expected text signature") + return + } + switch sig.Hash { + case crypto.SHA1: + c.Hash = "SHA1" + case crypto.SHA256: + c.Hash = "SHA256" default: - panic("reder: unknown type") + err = fmt.Errorf("CleanSigned: expected SHA1 or SHA256 signature hash") + return } - s := "Content-Type: " + ContentType[doctype] + "\n\n" - fields := marshal(v) - for _, f := range fields { - s += f.Key + ": " + f.Value + "\n" + // TODO: check CreationTime and other subpackets + if sig.SigLifetimeSecs != nil && *sig.SigLifetimeSecs != 0 { + err = fmt.Errorf("CleanSigned: signature must not expire") + return } - return []byte(s), nil -} - -func ParseDraft(s []byte) (draft *Draft, err error) { - v, err := parse(s, "draft") + out := new(bytes.Buffer) + w, err := armor.Encode(out, openpgp.SignatureType, nil) + if err != nil { + return + } + err = sig.Serialize(w) + if err != nil { + return + } + err = w.Close() if err != nil { return } - draft = v.(*Draft) + c.Signature = out.Bytes() return } -func RenderDraft(draft *Draft) ([]byte, error) { - return render(draft) +// create clear signed document +func FormatSigned(c *Signed) (data []byte, err error) { + s := ClearSignedHeader + "\n" + if c.Hash != "" { + s += "Hash: " + c.Hash + "\n" + } + s += "\n" + s += string(c.Body) + s += "\n" + s += string(c.Signature) + data = []byte(s) + return } -func ParseCert(s []byte) (cert *Cert, err error) { - v, err := parse(s, "cert") +// parse type and fields of a document body +func ParseDocument(body []byte) (doc *Document, err error) { + // parse content type header first + fields, s, err := ParseFields(body) if err != nil { - return nil, err + return + } + ctype, ok := fields["Content-Type"] + if len(fields) != 1 || !ok { + return nil, fmt.Errorf("ParseBody: expected a single Content-Type header field") + } + doc = new(Document) + for k, v := range ContentType { + if ctype == v { + doc.Type = k + break + } + } + if doc.Type == "" { + return nil, fmt.Errorf("ParseBody: unknown Content-Type: %s", ctype) + } + // TODO: doc.Order + doc.Fields, s, err = ParseFields(s) + if err == nil && len(s) > 0 { + err = fmt.Errorf("ParseBody: extra data after fields: %q", s) } - cert = v.(*Cert) return } -func RenderCert(cert *Cert) ([]byte, error) { - return render(cert) -} - -func formatId(s string) string { - return fmt.Sprintf("%040X", s) -} - -func parseId(s string) (string, error) { - dst := make([]byte, 20) - if len(s) != 40 { - return "", fmt.Errorf("parseId: expected 40 characters; got %d", len(s)) +// create document body +func FormatDocument(doc *Document) (body []byte, err error) { + ctype, ok := ContentType[doc.Type] + if !ok { + err = fmt.Errorf("FormatDocument: unknown document type: %s", doc.Type) + return } - _, err := hex.Decode(dst, []byte(s)) - return string(dst), err -} - -func quoteValue(s string) string { - return s -} - -func unquoteValue(s string) (string, error) { - return s, nil -} - -func formatDate(i int64) string { - return time.SecondsToUTC(i).Format(time.RFC3339) -} - -func parseDate(s string) (int64, error) { - t, err := time.Parse(time.RFC3339, s) - if err != nil { - return 0, err + s := "Content-Type: " + ctype + "\n\n" + for _, k := range doc.Order { + s += k + ": " + doc.Fields[k] + "\n" } - return t.Seconds(), nil + return []byte(s), nil } -func marshal(iv interface{}) []Field { - v := reflect.ValueOf(iv) - if v.Kind() != reflect.Ptr || v.IsNil() || v.Elem().Kind() != reflect.Struct { - panic("unmarshal: input is not a pointer to struct") +// parse doc fields into a struct according to the document type +func ParseStruct(doc *Document) (iv interface{}, err error) { + switch doc.Type { + case "Draft": + iv = new(Draft) + case "Notice": + iv = new(Notice) + case "DebitCert": + iv = new(DebitCert) + case "CreditCert": + iv = new(CreditCert) + case "BounceCert": + iv = new(BounceCert) + default: + err = fmt.Errorf("ParseStruct: unkown doc type: %s", doc.Type) + return } - v = v.Elem() + seen := make(map[string]bool) + v := reflect.ValueOf(iv).Elem() t := v.Type() n := v.NumField() - fields := []Field{} + nokey := 0 for i := 0; i < n; i++ { ft := t.Field(i) fv := v.Field(i) - m := ft.Tag.Get("marshal") - k := ft.Tag.Get("key") - if k == "" { - k = ft.Name + key := fieldname[ft.Name] + if key == "" { + key = ft.Name } - val := "" - switch fv.Kind() { - case reflect.String: - switch m { - case "id": - val = formatId(fv.String()) - case "": - val = quoteValue(fv.String()) - default: - panic("bad string field tag") + seen[key] = true + s, ok := doc.Fields[key] + if !ok { + if fv.Kind() == reflect.Ptr { + // missing optional key: leave the pointer as nil + nokey++ + continue } - case reflect.Int, reflect.Int32, reflect.Int64: - switch m { - case "date": - val = formatDate(fv.Int()) - case "": - val = strconv.Itoa64(fv.Int()) - default: - panic("bad int field tag") - } - case reflect.Uint, reflect.Uint32, reflect.Uint64: - switch m { - case "": - val = strconv.Uitoa64(fv.Uint()) - default: - panic("bad uint field tag") + return nil, fmt.Errorf("ParseStruct: field %s of %s is missing\n", key, t.Name()) + } + if fv.Kind() == reflect.Ptr { + if s == "" || s == "-" { + // TODO + // empty optional key: same as missing + continue } - case reflect.Slice: - switch m { - case "idlist": - if fv.Type().Elem().Kind() != reflect.String { - panic("only string slice is supported") - } - k := fv.Len() - for j := 0; j < k; j++ { - if j > 0 { - val += " " - } - val += formatId(fv.Index(j).String()) + fv.Set(reflect.New(fv.Type().Elem())) + fv = fv.Elem() + } + switch fieldtype[key] { + case "id": + var val string + val, err = parseId(s) + fv.SetString(val) + case "text": + var val string + val, err = parseString(s) + fv.SetString(val) + case "int": + var val int64 + val, err = strconv.Atoi64(s) + fv.SetInt(val) + case "date": + var val int64 + val, err = parseDate(s) + fv.SetInt(val) + case "ids": + // TODO: empty slice? + ids := strings.Split(s, " ") + val := make([]string, len(ids)) + for j, id := range ids { + val[j], err = parseId(id) + if err != nil { + return } - default: - panic("bad slice field tag") } + fv.Set(reflect.ValueOf(val)) default: - panic("bad field type") + panic("bad field type " + key + " " + fieldtype[key]) + } + if err != nil { + return + } + } + if len(doc.Fields)+nokey != n { + for k := range doc.Fields { + if !seen[k] { + err = fmt.Errorf("ParseStruct: unknown field %s in %s", k, t.Name()) + return + } } - fields = append(fields, Field{k, val}) } - return fields + return } -func unmarshal(fields []Field, iv interface{}) error { +// turn a struct into a document +func FormatStruct(iv interface{}) (doc *Document, err error) { v := reflect.ValueOf(iv) if v.Kind() != reflect.Ptr || v.IsNil() || v.Elem().Kind() != reflect.Struct { - panic("unmarshal: input is not a pointer to struct") + panic("input is not a pointer to struct") } v = v.Elem() t := v.Type() n := v.NumField() - if len(fields) != n { - return fmt.Errorf("unmarshal: %s has %d fields, got %d\n", t.Name(), n, len(fields)) - } + doc = new(Document) + doc.Type = t.Name() + doc.Fields = make(map[string]string) for i := 0; i < n; i++ { ft := t.Field(i) fv := v.Field(i) - m := ft.Tag.Get("marshal") - k := ft.Tag.Get("key") - if k == "" { - k = ft.Name + key := fieldname[ft.Name] + if key == "" { + key = ft.Name } - if fields[i].Key != k { - return fmt.Errorf("unmarshal: field %d of %s (%s) is missing\n", i, t.Name(), k) - } - s := fields[i].Value - var err error - switch fv.Kind() { - case reflect.String: - var val string - switch m { - case "id": - val, err = parseId(s) - case "": - val, err = unquoteValue(s) - default: - panic("bad string field tag") - } - fv.SetString(val) - case reflect.Int, reflect.Int32, reflect.Int64: - var val int64 - switch m { - case "date": - val, err = parseDate(s) - case "": - val, err = strconv.Atoi64(s) - default: - panic("bad int field tag") - } - fv.SetInt(val) - case reflect.Uint, reflect.Uint32, reflect.Uint64: - var val uint64 - switch m { - case "": - val, err = strconv.Atoui64(s) - default: - panic("bad uint field tag") + val := "" + if fv.Kind() == reflect.Ptr { + if fv.IsNil() { + // keep empty optional fields but mark them + val = "-" + goto setval } - fv.SetUint(val) - case reflect.Slice: - var val []string - switch m { - case "idlist": - if fv.Type().Elem().Kind() != reflect.String { - panic("only string slice is supported") - } - ids := strings.Split(s, " ") - val = make([]string, len(ids)) - for j := range val { - val[j], err = parseId(ids[j]) - if err != nil { - return err - } + fv = fv.Elem() + } + switch fieldtype[key] { + case "id": + val = formatId(fv.String()) + case "text": + val = formatString(fv.String()) + case "int": + val = strconv.Itoa64(fv.Int()) + case "date": + val = formatDate(fv.Int()) + case "ids": + k := fv.Len() + for j := 0; j < k; j++ { + if j > 0 { + val += "\n " } - default: - panic("bad slice field tag") + val += formatId(fv.Index(j).String()) } - fv.Set(reflect.ValueOf(val)) default: - panic("bad field type") - } - if err != nil { - return err + panic("bad field type " + key + " " + fieldtype[key]) } + setval: + doc.Fields[key] = val + doc.Order = append(doc.Order, key) } - return nil + return } -func getLine(data []byte) (line, rest []byte) { - i := bytes.Index(data, []byte{'\n'}) - j := i + 1 - if i < 0 { - i = len(data) - j = i - } else if i > 0 && data[i-1] == '\r' { - i-- +func ParseFields(s []byte) (fields map[string]string, rest []byte, err error) { + rest = s + fields = make(map[string]string) + key := "" + // \n is optional after the last field and an extra \n is allowed as well + for len(rest) > 0 { + var line []byte + line, rest = getLine(rest) + // empty line after the last field is consumed + if len(line) == 0 { + break + } + if line[0] == ' ' && key != "" { + // "Key: v1\n v2\n" is equivalent to "Key: v1 v2\n" + fields[key] += string(line) + continue + } + if line[0] < 'A' || line[0] > 'Z' { + err = fmt.Errorf("ParseFields: field name must start with an upper-case ascii letter") + return + } + i := bytes.IndexByte(line, ':') + if i < 0 { + err = fmt.Errorf("ParseFields: missing ':'") + return + } + key = string(line[:i]) + if _, ok := fields[key]; ok { + err = fmt.Errorf("ParseFields: repeated fields are not allowed") + return + } + fields[key] = string(line[i+1:]) } - return data[:i], data[j:] + for key, v := range fields { + // either a single space follows ':' or the value is empty + // good: "Key:\n", "Key:\n value\n", "Key: value\n", "Key: v1\n v2\n" + // bad: "Key:value\n", "Key: \nvalue\n" + // bad but not checked here: "Key: \n", "Key: value \n", "Key:\n \n value\n" + if len(v) == 0 { + continue + } + if v[0] != ' ' { + err = fmt.Errorf("ParseFields: ':' is not followed by ' '") + return + } + fields[key] = v[1:] + } + return } -func trimspace(s []byte) []byte { - a := bytes.Split(s, []byte("\n")) - for i := range a { - a[i] = bytes.TrimRight(a[i], " \t\r") - } - return bytes.Join(a, []byte("\n")) +// TODO: limit errors + +func parseId(s string) (string, error) { + // check if hex decodable + // TODO: length check + dst := make([]byte, len(s)/2) + _, err := hex.Decode(dst, []byte(s)) + return s, err } -func dashesc(s []byte) []byte { - r := bytes.Replace(s, []byte("\n-"), []byte("\n- -"), -1) - if len(r) > 0 && r[0] == '-' { - r = append([]byte("- "), r...) - } - return r +func formatId(s string) string { + return s } -func dashunesc(s []byte) []byte { - r := bytes.Replace(s, []byte("\n- "), []byte("\n"), -1) - if len(r) >= 2 && r[0] == '-' && r[1] == ' ' { - r = r[2:] +func parseString(s string) (string, error) { + if len(s) > MaxValueLength { + return "", fmt.Errorf("parseString: length limit is exceeded") } - return r + return s, nil } -// RFC 4880 is unclear about multiple Hash header semantics, section 7. says -// "One or more "Hash" Armor Headers" -// then -// "If more than one message digest is used in the signature, the "Hash" -// armor header contains a comma-delimited list of used message digests." -// in section 6.2. -// "there is no limit to the length of Armor Headers. Care should -// be taken that the Armor Headers are short enough to survive -// transport. One way to do this is to repeat an Armor Header key -// multiple times with different values for each so that no one line is -// overly long." -// we accept a single Hash header with a list of hash algorithms for now -// but use the one specified by the signature +func formatString(s string) string { + return s +} -func split(s []byte) (hash, body, sig []byte) { - if !bytes.HasPrefix(s, []byte(ClearSignedHeader)) { - return - } - s = s[len(ClearSignedHeader):] - // only allow a single Hash: header - if bytes.HasPrefix(s, []byte("Hash: ")) { - s = s[len("Hash: "):] - hash, s = getLine(s) - } - // skip empty line - empty, s := getLine(s) - if len(empty) != 0 { - return +func parseDate(s string) (int64, error) { + // TODO: fractional seconds? + t, err := time.Parse(time.RFC3339, s) + if err != nil { + return 0, err } - i := bytes.Index(s, []byte("\n-----BEGIN")) + return t.Seconds(), nil +} + +func formatDate(i int64) string { + return time.SecondsToUTC(i).Format(time.RFC3339) +} + +func getLine(data []byte) (line, rest []byte) { + i := bytes.IndexByte(data, '\n') + j := i + 1 if i < 0 { - return - } - body, sig = s[:i], s[i+1:] - if i > 0 && body[i-1] == '\r' { - body = body[:i-1] + i = len(data) + j = i + } else if i > 0 && data[i-1] == '\r' { + i-- } - return + return data[:i], data[j:] }