userattribute.go

Documentation: github.com/ProtonMail/go-crypto/openpgp/packet

     1  // Copyright 2013 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 packet
     6  
     7  import (
     8  	"bytes"
     9  	"image"
    10  	"image/jpeg"
    11  	"io"
    12  	"io/ioutil"
    13  )
    14  
    15  const UserAttrImageSubpacket = 1
    16  
    17  // UserAttribute is capable of storing other types of data about a user
    18  // beyond name, email and a text comment. In practice, user attributes are typically used
    19  // to store a signed thumbnail photo JPEG image of the user.
    20  // See RFC 4880, section 5.12.
    21  type UserAttribute struct {
    22  	Contents []*OpaqueSubpacket
    23  }
    24  
    25  // NewUserAttributePhoto creates a user attribute packet
    26  // containing the given images.
    27  func NewUserAttributePhoto(photos ...image.Image) (uat *UserAttribute, err error) {
    28  	uat = new(UserAttribute)
    29  	for _, photo := range photos {
    30  		var buf bytes.Buffer
    31  		// RFC 4880, Section 5.12.1.
    32  		data := []byte{
    33  			0x10, 0x00, // Little-endian image header length (16 bytes)
    34  			0x01,       // Image header version 1
    35  			0x01,       // JPEG
    36  			0, 0, 0, 0, // 12 reserved octets, must be all zero.
    37  			0, 0, 0, 0,
    38  			0, 0, 0, 0}
    39  		if _, err = buf.Write(data); err != nil {
    40  			return
    41  		}
    42  		if err = jpeg.Encode(&buf, photo, nil); err != nil {
    43  			return
    44  		}
    45  
    46  		lengthBuf := make([]byte, 5)
    47  		n := serializeSubpacketLength(lengthBuf, len(buf.Bytes())+1)
    48  		lengthBuf = lengthBuf[:n]
    49  
    50  		uat.Contents = append(uat.Contents, &OpaqueSubpacket{
    51  			SubType:       UserAttrImageSubpacket,
    52  			EncodedLength: lengthBuf,
    53  			Contents:      buf.Bytes(),
    54  		})
    55  	}
    56  	return
    57  }
    58  
    59  // NewUserAttribute creates a new user attribute packet containing the given subpackets.
    60  func NewUserAttribute(contents ...*OpaqueSubpacket) *UserAttribute {
    61  	return &UserAttribute{Contents: contents}
    62  }
    63  
    64  func (uat *UserAttribute) parse(r io.Reader) (err error) {
    65  	// RFC 4880, section 5.13
    66  	b, err := ioutil.ReadAll(r)
    67  	if err != nil {
    68  		return
    69  	}
    70  	uat.Contents, err = OpaqueSubpackets(b)
    71  	return
    72  }
    73  
    74  // Serialize marshals the user attribute to w in the form of an OpenPGP packet, including
    75  // header.
    76  func (uat *UserAttribute) Serialize(w io.Writer) (err error) {
    77  	var buf bytes.Buffer
    78  	for _, sp := range uat.Contents {
    79  		err = sp.Serialize(&buf)
    80  		if err != nil {
    81  			return err
    82  		}
    83  	}
    84  	if err = serializeHeader(w, packetTypeUserAttribute, buf.Len()); err != nil {
    85  		return err
    86  	}
    87  	_, err = w.Write(buf.Bytes())
    88  	return
    89  }
    90  
    91  // ImageData returns zero or more byte slices, each containing
    92  // JPEG File Interchange Format (JFIF), for each photo in the
    93  // user attribute packet.
    94  func (uat *UserAttribute) ImageData() (imageData [][]byte) {
    95  	for _, sp := range uat.Contents {
    96  		if sp.SubType == UserAttrImageSubpacket && len(sp.Contents) > 16 {
    97  			imageData = append(imageData, sp.Contents[16:])
    98  		}
    99  	}
   100  	return
   101  }
   102
View as plain text