Update all deps

Godeps/_workspace/src/code.google.com/p/go.crypto/bcrypt/bcrypt_test.go

@@ -53,6 +53,15 @@ func TestBcryptingIsCorrect(t *testing.T) {
 	}
 }
 
+func TestVeryShortPasswords(t *testing.T) {
+	key := []byte("k")
+	salt := []byte("XajjQvNhvvRt5GSeFk1xFe")
+	_, err := bcrypt(key, 10, salt)
+	if err != nil {
+		t.Errorf("One byte key resulted in error: %s", err)
+	}
+}
+
 func TestTooLongPasswordsWork(t *testing.T) {
 	salt := []byte("XajjQvNhvvRt5GSeFk1xFe")
 	// One byte over the usual 56 byte limit that blowfish has

Godeps/_workspace/src/code.google.com/p/go.crypto/blowfish/blowfish_test.go

@@ -192,19 +192,13 @@ func TestCipherDecrypt(t *testing.T) {
 }
 
 func TestSaltedCipherKeyLength(t *testing.T) {
-	var key []byte
-	for i := 0; i < 4; i++ {
-		_, err := NewSaltedCipher(key, []byte{'a'})
-		if err != KeySizeError(i) {
-			t.Errorf("NewSaltedCipher with short key, gave error %#v, expected %#v", err, KeySizeError(i))
-		}
-		key = append(key, 'a')
+	if _, err := NewSaltedCipher(nil, []byte{'a'}); err != KeySizeError(0) {
+		t.Errorf("NewSaltedCipher with short key, gave error %#v, expected %#v", err, KeySizeError(0))
 	}
 
 	// A 57-byte key. One over the typical blowfish restriction.
-	key = []byte("012345678901234567890123456789012345678901234567890123456")
-	_, err := NewSaltedCipher(key, []byte{'a'})
-	if err != nil {
+	key := []byte("012345678901234567890123456789012345678901234567890123456")
+	if _, err := NewSaltedCipher(key, []byte{'a'}); err != nil {
 		t.Errorf("NewSaltedCipher with long key, gave error %#v", err)
 	}
 }

Godeps/_workspace/src/code.google.com/p/go.crypto/blowfish/cipher.go

@@ -26,14 +26,13 @@ func (k KeySizeError) Error() string {
 }
 
 // NewCipher creates and returns a Cipher.
-// The key argument should be the Blowfish key, 4 to 56 bytes.
+// The key argument should be the Blowfish key, from 1 to 56 bytes.
 func NewCipher(key []byte) (*Cipher, error) {
 	var result Cipher
-	k := len(key)
-	if k < 4 || k > 56 {
+	if k := len(key); k < 1 || k > 56 {
 		return nil, KeySizeError(k)
 	}
-	initCipher(key, &result)
+	initCipher(&result)
 	ExpandKey(key, &result)
 	return &result, nil
 }
@@ -44,11 +43,10 @@ func NewCipher(key []byte) (*Cipher, error) {
 // bytes. Only the first 16 bytes of salt are used.
 func NewSaltedCipher(key, salt []byte) (*Cipher, error) {
 	var result Cipher
-	k := len(key)
-	if k < 4 {
+	if k := len(key); k < 1 {
 		return nil, KeySizeError(k)
 	}
-	initCipher(key, &result)
+	initCipher(&result)
 	expandKeyWithSalt(key, salt, &result)
 	return &result, nil
 }
@@ -81,7 +79,7 @@ func (c *Cipher) Decrypt(dst, src []byte) {
 	dst[4], dst[5], dst[6], dst[7] = byte(r>>24), byte(r>>16), byte(r>>8), byte(r)
 }
 
-func initCipher(key []byte, c *Cipher) {
+func initCipher(c *Cipher) {
 	copy(c.p[0:], p[0:])
 	copy(c.s0[0:], s0[0:])
 	copy(c.s1[0:], s1[0:])