func SaltpackVerify(g *GlobalContext, source io.Reader, sink io.WriteCloser, checkSender func(saltpack.SigningPublicKey) error) error {
sc, newSource, err := ClassifyStream(source)
if err != nil {
return err
}
if sc.Format != CryptoMessageFormatSaltpack {
return WrongCryptoFormatError{
Wanted: CryptoMessageFormatSaltpack,
Received: sc.Format,
Operation: "verify",
}
}
source = newSource
kr := echoKeyring{Contextified: NewContextified(g)}
var skey saltpack.SigningPublicKey
var vs io.Reader
var frame saltpack.Frame
if sc.Armored {
skey, vs, frame, err = saltpack.NewDearmor62VerifyStream(source, kr)
} else {
skey, vs, err = saltpack.NewVerifyStream(source, kr)
}
if err != nil {
g.Log.Debug("saltpack.NewDearmor62VerifyStream error: %s", err)
return err
}
if checkSender != nil {
if err = checkSender(skey); err != nil {
return err
}
}
n, err := io.Copy(sink, vs)
if err != nil {
return err
}
if sc.Armored {
if brand, err := saltpack.CheckArmor62Frame(frame, saltpack.MessageTypeAttachedSignature); err != nil {
return err
} else if err = checkSaltpackBrand(brand); err != nil {
return err
}
}
g.Log.Debug("Verify: read %d bytes", n)
if err := sink.Close(); err != nil {
return err
}
return nil
}
func ExampleNewSignArmor62Stream() {
var err error
// Make a new Keyring, initialized to be empty
keyring := basic.NewKeyring()
// The test message
msg := []byte("The Magic Words are Squeamish Ossifrage")
// Make a secret key for the sender
var signer saltpack.SigningSecretKey
signer, err = keyring.GenerateSigningKey()
if err != nil {
return
}
// Make a new signature stream. We write the input data into
// the input stream, and we read output out of the output stream.
// In this case, the output stream is just a buffer.
var input io.WriteCloser
var output bytes.Buffer
input, err = saltpack.NewSignArmor62Stream(&output, signer, "")
if err != nil {
return
}
// Write the message into the input stream, and then close
input.Write(msg)
input.Close()
// The verified message. We pass the signed stream as the first argument
// as a stream (here a bytes.Buffer which is output from above), and read the
// verified data out of verified stream.
var verifiedStream io.Reader
var signingPublicKey saltpack.SigningPublicKey
signingPublicKey, verifiedStream, _, err = saltpack.NewDearmor62VerifyStream(&output, keyring)
if err != nil {
return
}
// Assert we got the right key back.
if saltpack.PublicKeyEqual(signingPublicKey, signer.GetPublicKey()) {
fmt.Println("The right key")
}
// Copy all of the data out of the verified stream, and into standard
// output, here for testing / comparison purposes.
io.Copy(os.Stdout, verifiedStream)
os.Stdout.Write([]byte{'\n'})
// Output:
// The right key
// The Magic Words are Squeamish Ossifrage
}
