Esempio n. 1
0
func TestDigest(t *testing.T) {
	hasher1 := NewHasher()
	hasher2 := NewHasher()
	hasher1.Write([]byte("Hello world"))
	hasher2.Write([]byte("Test123"))
	hash1 := hasher1.Finalize()
	hash2 := hasher2.Finalize()
	enc1, err1 := transfer.EncodeString(hash1)
	enc2, err2 := transfer.EncodeString(hash2)
	if hash1.Equal(hash2) {
		t.Fatal("Hashes match")
	}
	if err1 != nil || err2 != nil {
		t.Fatalf("Error encoding hashes")
	}
	t.Logf("Hash of 'Hello world' is: %s", enc1)
	t.Logf("Hash of 'Test123' is: %s", enc2)
	var dh1 *Digest
	err := transfer.DecodeString(enc1, &dh1)
	if err != nil {
		t.Fatalf("Error decoding hash: %s", err)
	}
	if !hash1.Equal(dh1) {
		t.Fatal("Hash didn't deserialize right")
	}
	hasher3 := NewHasher()
	hasher3.Write([]byte("Hello"))
	hasher3.Write([]byte(" "))
	hasher3.Write([]byte("world"))
	hash3 := hasher3.Finalize()
	if !hash1.Equal(hash3) {
		t.Fatal("Write alternate failed")
	}
}
Esempio n. 2
0
func TestIdent(t *testing.T) {
	s1 := NewSecretIdentity("pass1")
	s2 := NewSecretIdentity("pass2")
	p1 := s1.Public()
	if s1.Fingerprint().Equal(s2.Fingerprint()) {
		t.Fatal("Two identies with same fingerprint")
	}
	if !s1.Fingerprint().Equal(p1.Fingerprint()) {
		t.Fatal("Public and private fingerprints don't match")
	}
	x509 := s1.X509Certificate()
	p3, err := PublicFromCert(x509)
	if err != nil {
		t.Fatalf("Error during cert parse: %s", err)
	}
	if !p3.Fingerprint().Equal(p1.Fingerprint()) {
		t.Fatal("Certificate round trip failed")
	}
	p1enc, err := transfer.EncodeString(p1)
	if err != nil {
		t.Fatalf("Unable to encode public key")
	}
	t.Logf("Public key #1: %s", p1enc)
	var p4 *PublicIdentity
	err = transfer.DecodeString(p1enc, &p4)
	if err != nil {
		t.Fatalf("Unable to decode public key")
	}
	if !p4.Fingerprint().Equal(p1.Fingerprint()) {
		t.Fatal("Round trip of public key fails")
	}
	s1l := s1.Lock()
	s1le, err := transfer.EncodeString(s1l)
	if err != nil {
		t.Fatal("Unable to write locked private key: %s", err)
	}
	t.Logf("Locked private key: %s", s1le)
	var s1ld *LockedIdentity
	err = transfer.DecodeString(s1le, &s1ld)
	if err != nil {
		t.Fatal("Unable to decode locked key")
	}
	_, err = UnlockSecretIdentity(s1ld, "badpass")
	if err == nil {
		t.Fatal("Was able to unlock secret id with the wrong key")
	}
	t.Logf("Tried to use bad password, got: %s", err)
	s3, err := UnlockSecretIdentity(s1ld, "pass1")
	if err != nil {
		t.Fatalf("Unable to unlock id with correct password: %s", err)
	}
	if !s1.Fingerprint().Equal(s3.Fingerprint()) {
		t.Fatal("Unlocked new private key doesn't match original")
	}
	hasher := NewHasher()
	hasher.Write([]byte("Hello world"))
	digest := hasher.Finalize()
	sig2 := s2.Sign(digest)
	sig3 := s3.Sign(digest)
	sig3s, err := transfer.EncodeString(sig3)
	if err != nil {
		t.Fatalf("Unable to encode signature: %s", err)
	}
	t.Logf("Here is a signature: %s", sig3s)
	var sig4 *Signature
	err = transfer.DecodeString(sig3s, &sig4)
	if p1.Verify(digest, sig2) {
		t.Fatal("Bad signature worked")
	}
	if !p1.Verify(digest, sig4) {
		t.Fatal("Good signature failed")
	}
}