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 }