nsz Git - epoint/blob - pkg/key/key_test.go

   1 package key
   2
   3 import (
   4         "bytes"
   5         "crypto/openpgp"
   6         "fmt"
   7         "testing"
   8         "time"
   9 )
  10
  11 func testSignAndVerify(t *testing.T, priv *openpgp.Entity) {
  12         msg := []byte("testing")
  13         w := new(bytes.Buffer)
  14         err := openpgp.DetachSign(w, priv, bytes.NewBuffer(msg))
  15         if err != nil {
  16                 t.Errorf("error signing: %s", err)
  17                 return
  18         }
  19
  20         _, err = openpgp.CheckDetachedSignature(openpgp.EntityList{priv}, bytes.NewBuffer(msg), w)
  21         if err != nil {
  22                 t.Errorf("Verify failed: %s", err)
  23         }
  24 }
  25
  26 func TestKey(t *testing.T) {
  27         key, err := RandomDsaKey()
  28         if err != nil {
  29                 t.Errorf("gen dsa key failed: %s", err)
  30                 return
  31         }
  32         priv, err := New(key, time.Now(), "a", "b", "c")
  33         if err != nil {
  34                 t.Errorf("New failed: %s", err)
  35         } else {
  36                 testSignAndVerify(t, priv)
  37         }
  38
  39         // serialize
  40         err = SelfSign(priv)
  41         if err != nil {
  42                 t.Errorf("SelfSign failed: %s", err)
  43         }
  44         d, err := Format(priv)
  45         if err != nil {
  46                 t.Errorf("Format failed: %s", err)
  47         }
  48         _, err = Parse(d)
  49         if err != nil {
  50                 t.Errorf("Parse failed: %s", err)
  51         }
  52 }
  53
  54 func TestId(t *testing.T) {
  55         idwant := "E51F405B809FA2DEA760603F9D33F730611CBCD9"
  56         key, err := Issuer([]byte("rand"), "")
  57         if err != nil {
  58                 t.Errorf("Issuer failed: %s", err)
  59                 return
  60         }
  61         id := Id(key)
  62         if id != idwant {
  63                 t.Errorf("Id failed: expected %s, got %s", idwant, id)
  64         }
  65 }
  66
  67 func TestIssuerHolder(t *testing.T) {
  68         denomination := "1/100 EUR"
  69         priv, err := Issuer([]byte("issuer-rand"), denomination)
  70         if err != nil {
  71                 t.Errorf("Issuer failed: %s", err)
  72         } else {
  73                 testSignAndVerify(t, priv)
  74         }
  75         wpriv := new(bytes.Buffer)
  76         err = priv.SerializePrivate(wpriv)
  77         if err != nil {
  78                 t.Errorf("priv key serialization failed: %s", err)
  79                 return
  80         }
  81         wpub := new(bytes.Buffer)
  82         err = priv.Serialize(wpub)
  83         if err != nil {
  84                 t.Errorf("pub key serialization failed: %s", err)
  85                 return
  86         }
  87         es, err := openpgp.ReadKeyRing(wpub)
  88         if err != nil {
  89                 t.Errorf("pub key parsing failed: %s", err)
  90                 return
  91         }
  92         isIssuer, issuer, denom, err := Check(es[0])
  93         if err != nil {
  94                 t.Errorf("Check failed: %s", err)
  95                 return
  96         }
  97         if !isIssuer {
  98                 t.Errorf("expected issuer key got: %v", es[0].Identities)
  99         }
 100         issuerfpr := fmt.Sprintf("%X", priv.PrimaryKey.Fingerprint)
 101         if issuer != issuerfpr {
 102                 t.Errorf("expected issuer %s got %s", issuerfpr, issuer)
 103         }
 104         if denom != denomination {
 105                 t.Errorf("expected denomination %q got %q", denomination, denom)
 106         }
 107
 108         priv, err = Holder([]byte("holder-rand"), issuerfpr, denomination)
 109         if err != nil {
 110                 t.Errorf("Holder failed: %s", err)
 111         } else {
 112                 testSignAndVerify(t, priv)
 113         }
 114         wpriv = new(bytes.Buffer)
 115         err = priv.SerializePrivate(wpriv)
 116         if err != nil {
 117                 t.Errorf("priv key serialization failed: %s", err)
 118                 return
 119         }
 120         wpub = new(bytes.Buffer)
 121         err = priv.Serialize(wpub)
 122         if err != nil {
 123                 t.Errorf("pub key serialization failed: %s", err)
 124                 return
 125         }
 126         es, err = openpgp.ReadKeyRing(wpub)
 127         if err != nil {
 128                 t.Errorf("pub key parsing failed: %s", err)
 129                 return
 130         }
 131         isIssuer, issuer, denom, err = Check(es[0])
 132         if err != nil {
 133                 t.Errorf("Check failed: %s", err)
 134                 return
 135         }
 136         if isIssuer {
 137                 t.Errorf("expected non-issuer key got: %v", es[0].Identities)
 138         }
 139         if issuer != issuerfpr {
 140                 t.Errorf("expected issuer %s got %s", issuerfpr, issuer)
 141         }
 142         if denom != denomination {
 143                 t.Errorf("expected denomination %q got %q", denomination, denom)
 144         }
 145 }