]>
Commit | Line | Data |
---|---|---|
9b12e4fe JC |
1 | // Copyright 2010 The Go Authors. All rights reserved. |
2 | // Use of this source code is governed by a BSD-style | |
3 | // license that can be found in the LICENSE file. | |
4 | ||
5 | // Package blowfish implements Bruce Schneier's Blowfish encryption algorithm. | |
6 | package blowfish // import "golang.org/x/crypto/blowfish" | |
7 | ||
8 | // The code is a port of Bruce Schneier's C implementation. | |
9 | // See http://www.schneier.com/blowfish.html. | |
10 | ||
11 | import "strconv" | |
12 | ||
13 | // The Blowfish block size in bytes. | |
14 | const BlockSize = 8 | |
15 | ||
16 | // A Cipher is an instance of Blowfish encryption using a particular key. | |
17 | type Cipher struct { | |
18 | p [18]uint32 | |
19 | s0, s1, s2, s3 [256]uint32 | |
20 | } | |
21 | ||
22 | type KeySizeError int | |
23 | ||
24 | func (k KeySizeError) Error() string { | |
25 | return "crypto/blowfish: invalid key size " + strconv.Itoa(int(k)) | |
26 | } | |
27 | ||
28 | // NewCipher creates and returns a Cipher. | |
29 | // The key argument should be the Blowfish key, from 1 to 56 bytes. | |
30 | func NewCipher(key []byte) (*Cipher, error) { | |
31 | var result Cipher | |
32 | if k := len(key); k < 1 || k > 56 { | |
33 | return nil, KeySizeError(k) | |
34 | } | |
35 | initCipher(&result) | |
36 | ExpandKey(key, &result) | |
37 | return &result, nil | |
38 | } | |
39 | ||
40 | // NewSaltedCipher creates a returns a Cipher that folds a salt into its key | |
41 | // schedule. For most purposes, NewCipher, instead of NewSaltedCipher, is | |
42 | // sufficient and desirable. For bcrypt compatibility, the key can be over 56 | |
43 | // bytes. | |
44 | func NewSaltedCipher(key, salt []byte) (*Cipher, error) { | |
45 | if len(salt) == 0 { | |
46 | return NewCipher(key) | |
47 | } | |
48 | var result Cipher | |
49 | if k := len(key); k < 1 { | |
50 | return nil, KeySizeError(k) | |
51 | } | |
52 | initCipher(&result) | |
53 | expandKeyWithSalt(key, salt, &result) | |
54 | return &result, nil | |
55 | } | |
56 | ||
57 | // BlockSize returns the Blowfish block size, 8 bytes. | |
58 | // It is necessary to satisfy the Block interface in the | |
59 | // package "crypto/cipher". | |
60 | func (c *Cipher) BlockSize() int { return BlockSize } | |
61 | ||
62 | // Encrypt encrypts the 8-byte buffer src using the key k | |
63 | // and stores the result in dst. | |
64 | // Note that for amounts of data larger than a block, | |
65 | // it is not safe to just call Encrypt on successive blocks; | |
66 | // instead, use an encryption mode like CBC (see crypto/cipher/cbc.go). | |
67 | func (c *Cipher) Encrypt(dst, src []byte) { | |
68 | l := uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3]) | |
69 | r := uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7]) | |
70 | l, r = encryptBlock(l, r, c) | |
71 | dst[0], dst[1], dst[2], dst[3] = byte(l>>24), byte(l>>16), byte(l>>8), byte(l) | |
72 | dst[4], dst[5], dst[6], dst[7] = byte(r>>24), byte(r>>16), byte(r>>8), byte(r) | |
73 | } | |
74 | ||
75 | // Decrypt decrypts the 8-byte buffer src using the key k | |
76 | // and stores the result in dst. | |
77 | func (c *Cipher) Decrypt(dst, src []byte) { | |
78 | l := uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3]) | |
79 | r := uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7]) | |
80 | l, r = decryptBlock(l, r, c) | |
81 | dst[0], dst[1], dst[2], dst[3] = byte(l>>24), byte(l>>16), byte(l>>8), byte(l) | |
82 | dst[4], dst[5], dst[6], dst[7] = byte(r>>24), byte(r>>16), byte(r>>8), byte(r) | |
83 | } | |
84 | ||
85 | func initCipher(c *Cipher) { | |
86 | copy(c.p[0:], p[0:]) | |
87 | copy(c.s0[0:], s0[0:]) | |
88 | copy(c.s1[0:], s1[0:]) | |
89 | copy(c.s2[0:], s2[0:]) | |
90 | copy(c.s3[0:], s3[0:]) | |
91 | } |