// Create a new Client with specified ClientDescription
func NewClient(d ClientDescription) (*Client, error) {
client := new(http.Client)
encrypter, err := blowfish.NewCipher([]byte(d.EncryptKey))
if err != nil {
return nil, err
}
decrypter, err := blowfish.NewCipher([]byte(d.DecryptKey))
if err != nil {
return nil, err
}
return &Client{
description: d,
http: client,
encrypter: encrypter,
decrypter: decrypter,
}, nil
}
func newBlockCipher(cipherT string, key []byte) (cipher.Block, error) {
switch cipherT {
case "AES-128", "AES-256":
return aes.NewCipher(key)
case "Blowfish":
return bfish.NewCipher(key)
default:
return nil, fmt.Errorf("Unrecognized cipher type: %s", cipherT)
}
}
// Enc encrypts the data with the specified key
func Enc(ppt, key []byte) ([]byte, error) {
ppt = blowfishChecksizeAndPad(ppt)
ecipher, err := blowfish.NewCipher(key)
if err != nil {
return nil, err
}
ciphertext := make([]byte, blowfish.BlockSize+len(ppt))
eiv := ciphertext[:blowfish.BlockSize]
ecbc := cipher.NewCBCEncrypter(ecipher, eiv)
ecbc.CryptBlocks(ciphertext[blowfish.BlockSize:], ppt)
return ciphertext, nil
}
// Dec decrypts the data with the specified key
func Dec(et, key []byte) ([]byte, error) {
dcipher, err := blowfish.NewCipher(key)
if err != nil {
return nil, err
}
div := et[:blowfish.BlockSize]
decrypted := et[blowfish.BlockSize:]
if len(decrypted)%blowfish.BlockSize != 0 {
return nil, errors.New("decrypted is not a multiple of blowfish.BlockSize")
}
dcbc := cipher.NewCBCDecrypter(dcipher, div)
dcbc.CryptBlocks(decrypted, decrypted)
return bytes.Trim(decrypted, "\x00"), nil
}
func encryptFile(source, dst string, key []byte) error {
sourcebytes, err := ioutil.ReadFile(source)
if err != nil {
return err
}
sourceHash := createHash(sourcebytes)
sourcebytes = append(sourcebytes, sourceHash...)
if err != nil {
return err
}
aesCipher, err := aes.NewCipher(key)
blowfishCipher, err := blowfish.NewCipher(key)
if err != nil {
return err
}
iv := make([]byte, 16)
_, err = rand.Read(iv)
aesEncrypter := cipher.NewCFBEncrypter(aesCipher, iv)
blowfishEncrypter := cipher.NewCFBEncrypter(blowfishCipher, iv[0:8])
destbytes := make([]byte, len(sourcebytes))
aesEncrypter.XORKeyStream(destbytes, sourcebytes)
sourcebytes = destbytes
blowfishEncrypter.XORKeyStream(destbytes, sourcebytes)
if err != nil {
return err
}
destbytes = append(destbytes, iv...)
//TODO: Use the same credentials as the source
ioutil.WriteFile(dst, destbytes, 777)
return nil
}
func main() {
key := []byte("my key")
cipher, err := blowfish.NewCipher(key)
if err != nil {
fmt.Println(err.Error())
}
src := []byte("hello\n\n\n")
var enc [512]byte
cipher.Encrypt(enc[0:], src)
//fmt.Println(string(enc[0:]))
var decrypt [8]byte
cipher.Decrypt(decrypt[0:], enc[0:])
result := bytes.NewBuffer(nil)
result.Write(decrypt[0:8])
fmt.Println(string(result.Bytes()))
}
// Generate returns a secure token for use with a request to an Edgecast cache
// host.
//
// The secret is used to encrypt the params string. The params string must not
// be longer than 512 chars.
func Generate(secret, params string) (string, error) {
if len(params) >= maxTokenChars {
return "", errors.New("Input too long")
}
plaintext := []byte(fmt.Sprintf("ec_secure=%03d&%s", len(params)+14, params))
block, err := blowfish.NewCipher([]byte(secret))
if err != nil {
return "", err
}
ivec := make([]byte, blowfish.BlockSize)
stream := cipher.NewCFBEncrypter(block, ivec)
ciphertext := make([]byte, len(plaintext))
stream.XORKeyStream(ciphertext, plaintext)
return fmt.Sprintf("%02x", ciphertext), nil
}
func init() {
_debug = NewDebug(SYSTEM, "formal/padded")
SetNewCipherFunc("aes",
func(key []byte) (c cipher.Block, e error) {
c, e = aes.NewCipher(key)
return
})
SetNewCipherFunc("blowfish",
func(key []byte) (c cipher.Block, e error) {
c, e = blowfish.NewCipher(key)
return
})
SetPaddingFuncs("dtgpadding", dtgPad, dtgRemove)
SetPaddingFuncs("pkcs5padding", pkcs5Pad, pkcs5Remove)
SetPaddingFuncs("pkcs7padding", pkcs5Pad, pkcs5Remove)
SetPaddingFuncs("zeropadding", zeroPaddingPad, zeroPaddingRemove)
SetModeFuncs("ecb", NewECBEncrypter, NewECBDecrypter)
SetModeFuncs("cbc", cipher.NewCBCEncrypter, cipher.NewCBCDecrypter)
SetModeFuncs("rcbc", NewRCBCEncrypter, NewRCBCDecrypter)
}
func decryptFile(source, dst string, key []byte) error {
sourcebytes, err := ioutil.ReadFile(source)
if err != nil {
return err
}
iv := sourcebytes[len(sourcebytes)-16:]
sourcebytes = sourcebytes[:len(sourcebytes)-16]
contentLength := len(sourcebytes)
destbytes := make([]byte, contentLength)
aesCipher, err := aes.NewCipher(key)
if err != nil {
return err
}
blowfishCipher, err := blowfish.NewCipher(key)
blowFishDecryptor := cipher.NewCFBDecrypter(blowfishCipher, iv[0:8])
blowFishDecryptor.XORKeyStream(destbytes, sourcebytes)
sourcebytes = destbytes
aesDecryptor := cipher.NewCFBDecrypter(aesCipher, iv)
aesDecryptor.XORKeyStream(destbytes, sourcebytes)
h := destbytes[len(destbytes)-32:]
destbytes = destbytes[:len(destbytes)-32]
if !areEqual(h, createHash(destbytes)) {
return fmt.Errorf("Wrong password")
}
//TODO: Use the same credentials as the source
ioutil.WriteFile(dst, destbytes, 777)
return nil
}
func newBlowFishStream(key, iv []byte, doe DecOrEnc) (cipher.Stream, error) {
block, err := blowfish.NewCipher(key)
return newStream(block, err, key, iv, doe)
}
func (e *Engine) blowfish_ctr() error {
return e.ctr(func(key []byte) (cipher.Block, error) { return blowfish.NewCipher(key) })
}
func (e *Engine) unblowfish_cfb() error {
return e.uncfb(func(key []byte) (cipher.Block, error) { return blowfish.NewCipher(key) })
}
// Blowfish: obsolete, but for fun
func BenchmarkBlowfish_1K(b *testing.B) {
block, _ := blowfish.NewCipher(buf[:32])
benchmarkBlock(b, block, 1024)
}