Brian Gitonga Marete
c24604da51
This patch/CL allows the user to configure the hash function used in the s2k key-stretching transformation during encryption. It fixes the current limitation in which SHA1 is hard-coded for that task. With this change, packet.Config.DefaultHash is used by default for the mode 3 s2k key-stretching that is currently used for encryption, but the user may choose any other valid openpgp hash by passing a new (possibly nil) pointer argument to s2k.Serialize(). Note that this change introduces an API change to s2k.Serialize() in the form of an additional argument. However, the s2k package is a low-level facility that (as far as I could tell) is used directly by go.crypto/openpgp only. The CL comes with an modified test to check the use and decoding of all the valid hash functions with regard to s2k.Serialize(). This patch should be followed by one that allows the user to configure the iteration count in mode 3 s2k, and it is a prerequisite for that forthcoming change. R=golang-codereviews, agl CC=agl, golang-codereviews https://golang.org/cl/160110045
135 lines
3.1 KiB
Go
135 lines
3.1 KiB
Go
// Copyright 2011 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package s2k
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto"
|
|
_ "crypto/md5"
|
|
"crypto/rand"
|
|
"crypto/sha1"
|
|
_ "crypto/sha256"
|
|
_ "crypto/sha512"
|
|
"encoding/hex"
|
|
"testing"
|
|
|
|
_ "code.google.com/p/go.crypto/ripemd160"
|
|
)
|
|
|
|
var saltedTests = []struct {
|
|
in, out string
|
|
}{
|
|
{"hello", "10295ac1"},
|
|
{"world", "ac587a5e"},
|
|
{"foo", "4dda8077"},
|
|
{"bar", "bd8aac6b9ea9cae04eae6a91c6133b58b5d9a61c14f355516ed9370456"},
|
|
{"x", "f1d3f289"},
|
|
{"xxxxxxxxxxxxxxxxxxxxxxx", "e00d7b45"},
|
|
}
|
|
|
|
func TestSalted(t *testing.T) {
|
|
h := sha1.New()
|
|
salt := [4]byte{1, 2, 3, 4}
|
|
|
|
for i, test := range saltedTests {
|
|
expected, _ := hex.DecodeString(test.out)
|
|
out := make([]byte, len(expected))
|
|
Salted(out, h, []byte(test.in), salt[:])
|
|
if !bytes.Equal(expected, out) {
|
|
t.Errorf("#%d, got: %x want: %x", i, out, expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
var iteratedTests = []struct {
|
|
in, out string
|
|
}{
|
|
{"hello", "83126105"},
|
|
{"world", "6fa317f9"},
|
|
{"foo", "8fbc35b9"},
|
|
{"bar", "2af5a99b54f093789fd657f19bd245af7604d0f6ae06f66602a46a08ae"},
|
|
{"x", "5a684dfe"},
|
|
{"xxxxxxxxxxxxxxxxxxxxxxx", "18955174"},
|
|
}
|
|
|
|
func TestIterated(t *testing.T) {
|
|
h := sha1.New()
|
|
salt := [4]byte{4, 3, 2, 1}
|
|
|
|
for i, test := range iteratedTests {
|
|
expected, _ := hex.DecodeString(test.out)
|
|
out := make([]byte, len(expected))
|
|
Iterated(out, h, []byte(test.in), salt[:], 31)
|
|
if !bytes.Equal(expected, out) {
|
|
t.Errorf("#%d, got: %x want: %x", i, out, expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
var parseTests = []struct {
|
|
spec, in, out string
|
|
}{
|
|
/* Simple with SHA1 */
|
|
{"0002", "hello", "aaf4c61d"},
|
|
/* Salted with SHA1 */
|
|
{"01020102030405060708", "hello", "f4f7d67e"},
|
|
/* Iterated with SHA1 */
|
|
{"03020102030405060708f1", "hello", "f2a57b7c"},
|
|
}
|
|
|
|
func TestParse(t *testing.T) {
|
|
for i, test := range parseTests {
|
|
spec, _ := hex.DecodeString(test.spec)
|
|
buf := bytes.NewBuffer(spec)
|
|
f, err := Parse(buf)
|
|
if err != nil {
|
|
t.Errorf("%d: Parse returned error: %s", i, err)
|
|
continue
|
|
}
|
|
|
|
expected, _ := hex.DecodeString(test.out)
|
|
out := make([]byte, len(expected))
|
|
f(out, []byte(test.in))
|
|
if !bytes.Equal(out, expected) {
|
|
t.Errorf("%d: output got: %x want: %x", i, out, expected)
|
|
}
|
|
if testing.Short() {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSerialize(t *testing.T) {
|
|
hashes := []crypto.Hash{crypto.MD5, crypto.SHA1, crypto.RIPEMD160,
|
|
crypto.SHA256, crypto.SHA384, crypto.SHA512, crypto.SHA224}
|
|
for _, h := range hashes {
|
|
testSerializeConfig(t, &Config{Hash: h})
|
|
}
|
|
}
|
|
|
|
func testSerializeConfig(t *testing.T, c *Config) {
|
|
t.Logf("Running testSerializeConfig() with config: %+v", c)
|
|
|
|
buf := bytes.NewBuffer(nil)
|
|
key := make([]byte, 16)
|
|
passphrase := []byte("testing")
|
|
err := Serialize(buf, key, rand.Reader, passphrase, c)
|
|
if err != nil {
|
|
t.Errorf("failed to serialize: %s", err)
|
|
return
|
|
}
|
|
|
|
f, err := Parse(buf)
|
|
if err != nil {
|
|
t.Errorf("failed to reparse: %s", err)
|
|
return
|
|
}
|
|
key2 := make([]byte, len(key))
|
|
f(key2, passphrase)
|
|
if !bytes.Equal(key2, key) {
|
|
t.Errorf("keys don't match: %x (serialied) vs %x (parsed)", key, key2)
|
|
}
|
|
}
|