2

3 /**

4 * Blowfish.java version 1.00.00

5 *

6 * Code Written by k2r (k2r.contact@gmail.com)

31 import java.io.UnsupportedEncodingException;

32 import java.security.InvalidKeyException;

33 import javax.crypto.Cipher;

34 import javax.crypto.spec.SecretKeySpec;

35 import org.slf4j.Logger;

36 import org.slf4j.LoggerFactory;

37

38 public class Blowfish

39 {

40 private static final Logger log = LoggerFactory.getLogger(Blowfish.class);

32 class Crypto:

33

34 _BlockSize = {'AES':16, 'ARC2':8, 'ARC4':1, 'Blowfish':8, 'CAST':8,

35 'DES':8, 'DES3':8, 'IDEA':8, 'RC5':8, 'XOR':1}

36 _Modes = ['ECB', 'CBC', 'CFB', 'OFB', 'PGP'] #CTR needs 4 args

62 #avoid Memmory Error

63 if self.cipher=='RC5' and self.keysize in (1, 57): self.keysize=32

64 #try to import Crypto.Cipher.xxxx

65 try:

66 cipherlib = __import__('Crypto.Cipher.'+self.cipher, fromlist='x')

1 -- |

2 -- Module : Crypto.Cipher

3 -- License : BSD-style

4 -- Maintainer : Vincent Hanquez <vincent@snarc.org>

11 -- A simplified example (with simplified error handling):

12 --

13 -- > import Crypto.Cipher

14 -- > import Data.ByteString (ByteString)

15 -- > import qualified Data.ByteString as B

44 -- * Cipher implementations

45 , AES128, AES192, AES256

46 , Blowfish, Blowfish64, Blowfish128, Blowfish256, Blowfish448

47 , DES

48 , DES_EEE3, DES_EDE3, DES_EEE2, DES_EDE2

53 import Crypto.Cipher.AES (AES128, AES192, AES256)

54 import Crypto.Cipher.Blowfish

55 import Crypto.Cipher.DES

22 import java.io.IOException;

23

24 import javax.crypto.Cipher;

25 import javax.crypto.CipherInputStream;

26 import javax.crypto.CipherOutputStream;

27 import javax.crypto.spec.SecretKeySpec;

28

33 import com.esotericsoftware.kryo.io.Output;

34

35 /** Encrypts data using the blowfish cipher.

36 * @author Nathan Sweet <misc@n4te.com> */

37 public class BlowfishSerializer extends Serializer {

39 static private SecretKeySpec keySpec;

40

41 public BlowfishSerializer (Serializer serializer, byte[] key) {

42 this.serializer = serializer;

43 keySpec = new SecretKeySpec(key, "Blowfish");

21 import org.apache.log4j.Logger;

22

23 import javax.crypto.Cipher;

24 import javax.crypto.KeyGenerator;

25 import javax.crypto.SecretKey;

29

30 /**

31 * Key generator. It generates keys or keyPairs for Blowfish and RSA

32 *

33 * @author -Nemesiss-

57 log.info("Initializing Key Generator...");

58

59 blowfishKeyGen = KeyGenerator.getInstance("Blowfish");

60

61 KeyPairGenerator rsaKeyPairGenerator = KeyPairGenerator.getInstance("RSA");

4 pkg_resources.require( "pycrypto" )

5

6 from Crypto.Cipher import Blowfish

7 from Crypto.Util.randpool import RandomPool

8 from Crypto.Util import number

36 def __init__( self, **config ):

37 self.id_secret = config['id_secret']

38 self.id_cipher = Blowfish.new( self.id_secret )

39

40 def encode_id( self, obj_id ):

3

4 import Test.Framework (defaultMain, testGroup)

5 import Crypto.Cipher.Blowfish

6 import Crypto.Cipher.Types

7 import Crypto.Cipher.Tests

8 import Data.ByteString.Char8 () -- orphan IsString for older bytestring versions

9

48

49 main = defaultMain

50 [ testBlockCipher kats (undefined :: Blowfish64)

51 ]

52

6 import galaxy.exceptions

7

8 from Crypto.Cipher import Blowfish

9 from Crypto.Util.randpool import RandomPool

10 from Crypto.Util import number

39 def __init__( self, **config ):

40 self.id_secret = config['id_secret']

41 self.id_cipher = Blowfish.new( self.id_secret )

42

43 per_kind_id_secret_base = config.get( 'per_kind_id_secret_base', self.id_secret )

128

129 def __missing__( self, key ):

130 return Blowfish.new( self.secret_base + "__" + key )

131

11 *

12 */

13 import javax.crypto.Cipher;

14 import javax.crypto.KeyGenerator;

15 import javax.crypto.SecretKey;

23 public class Eryptogram {

24 private static String Algorithm = "DES";

25 // ?? ????,?? DES,DESede,Blowfish

26 static boolean debug = false;

27

194 // Pass Phrase.

195 SecretKey desKey = KeyGenerator.getInstance("DES").generateKey();

196 SecretKey blowfishKey = KeyGenerator.getInstance("Blowfish").generateKey();

197 SecretKey desedeKey = KeyGenerator.getInstance("DESede").generateKey();

198

199 // Create encrypter/decrypter class

200 StringEncrypter desEncrypter = new StringEncrypter(desKey, desKey.getAlgorithm());

201 StringEncrypter blowfishEncrypter = new StringEncrypter(blowfishKey, blowfishKey.getAlgorithm());

202 StringEncrypter desedeEncrypter = new StringEncrypter(desedeKey, desedeKey.getAlgorithm());

203

209 // Decrypt the string

210 String desDecrypted = desEncrypter.decrypt(desEncrypted);

211 String blowfishDecrypted = blowfishEncrypter.decrypt(blowfishEncrypted);

212 String desedeDecrypted = desedeEncrypter.decrypt(desedeEncrypted);

213

35 import java.security.NoSuchAlgorithmException;

36

37 import javax.crypto.Cipher;

38 import javax.crypto.NoSuchPaddingException;

39 import javax.crypto.spec.IvParameterSpec;

47 * @version $Revision: 1.21 $

48 */

49 public class BlowfishCbc extends SshCipher {

50 private static Log log = LogFactory.getLog(BlowfishCbc.class);

51

52 /** */

53 protected static String algorithmName = "blowfish-cbc";

54 Cipher cipher;

55

56 /**

57 * Creates a new BlowfishCbc object.

58 */

59 public BlowfishCbc() {

1 import javax.crypto.Cipher;

2 import java.security.Key;

3 import java.security.KeyStore;

16 import java.io.*;

17

18 public class BlowfishKey {

19

20 public static void main(String[] args) throws Exception {

33

34 public static byte[] encrypt(String plainText) throws Exception {

35 Cipher cipher = Cipher.getInstance("Blowfish");

36 cipher.init(Cipher.ENCRYPT_MODE, getKeySpec());

37 return cipher.doFinal(plainText.getBytes());

47

48 public static String decrypt(byte[] cipherText) throws Exception {

49 Cipher cipher = Cipher.getInstance("Blowfish");

50 cipher.init(Cipher.DECRYPT_MODE, getKeySpec());

51 byte[] decrypted = cipher.doFinal(cipherText);

3 import sys

4 import os

5 from Crypto.Cipher import Blowfish #for password storage

6 from hashlib import sha1

7 from random import randrange

51 def set_password(self, key, password):

52 cryptkey = sha1(key).hexdigest()

53 bf = Blowfish.new(cryptkey, Blowfish.MODE_ECB)

54 encrypted_pass = bf.encrypt(self._pad_pass(password))

55 del password

58 def get_password(self, key):

59 cryptkey = sha1(key).hexdigest()

60 bf = Blowfish.new(cryptkey, Blowfish.MODE_ECB)

61 try:

62 encrypted_pass = b64dec(self[cryptkey])

1

2 package ch.ethz.ssh2.crypto.cipher;

3

4 import java.util.Vector;

34 /* Higher Priority First */

35

36 ciphers.addElement(new CipherEntry("aes256-ctr", 16, 32, "ch.ethz.ssh2.crypto.cipher.AES"));

37 ciphers.addElement(new CipherEntry("aes192-ctr", 16, 24, "ch.ethz.ssh2.crypto.cipher.AES"));

38 ciphers.addElement(new CipherEntry("aes128-ctr", 16, 16, "ch.ethz.ssh2.crypto.cipher.AES"));

39 ciphers.addElement(new CipherEntry("blowfish-ctr", 8, 16, "ch.ethz.ssh2.crypto.cipher.BlowFish"));

40

41 ciphers.addElement(new CipherEntry("aes256-cbc", 16, 32, "ch.ethz.ssh2.crypto.cipher.AES"));

43 ciphers.addElement(new CipherEntry("aes128-cbc", 16, 16, "ch.ethz.ssh2.crypto.cipher.AES"));

44 ciphers.addElement(new CipherEntry("blowfish-cbc", 8, 16, "ch.ethz.ssh2.crypto.cipher.BlowFish"));

45

46 ciphers.addElement(new CipherEntry("3des-ctr", 8, 24, "ch.ethz.ssh2.crypto.cipher.DESede"));

4 pkg_resources.require( "pycrypto" )

5

6 from Crypto.Cipher import Blowfish

7 from Crypto.Util.randpool import RandomPool

8 from Crypto.Util import number

34 def __init__( self, **config ):

35 self.id_secret = config['id_secret']

36 self.id_cipher = Blowfish.new( self.id_secret )

37 def encode_id( self, id ):

38 # Convert to string

4 pkg_resources.require( "pycrypto" )

5

6 from Crypto.Cipher import Blowfish

7 from Crypto.Util.randpool import RandomPool

8 from Crypto.Util import number

34 def __init__( self, **config ):

35 self.id_secret = config['id_secret']

36 self.id_cipher = Blowfish.new( self.id_secret )

37 def encode_id( self, obj_id ):

38 # Convert to string

9 Here a simple example on how to encrypt using ECB, with the AES256 cipher:

10

11 import Crypto.Cipher.Types

12 import Crypto.Cipher

22 where ctx = initAES256 key

23

24 And another using CBC mode with Blowfish cipher:

25

26 import Crypto.Cipher.Types

27 import Crypto.Cipher

28

29 initBlowfish :: ByteString -> Blowfish

30 initBlowfish = either (error . show) cipherInit . makeKey

31

32 cryptKey key iv msg = encryptCBC ctx (makeIV iv) msg

33 where ctx = initBlowfish key

34

35

33 '''

34

35 from Crypto.Cipher import Blowfish

36 from elixir.statements import Statement

37 from sqlalchemy.orm import MapperExtension, EXT_CONTINUE, EXT_STOP

52

53 def encrypt_value(value, secret):

54 return Blowfish.new(secret, Blowfish.MODE_CFB) \

55 .encrypt(value).encode('string_escape')

56

57 def decrypt_value(value, secret):

58 return Blowfish.new(secret, Blowfish.MODE_CFB) \

59 .decrypt(value.decode('string_escape'))

60

30 -- | 256 bit keyed blowfish state

31 newtype Blowfish256 = Blowfish256 Context

32

33 -- | 448 bit keyed blowfish state

37 cipherName _ = "blowfish"

38 cipherKeySize _ = KeySizeRange 6 56

39 cipherInit k = either error Blowfish $ initBlowfish (toBytes k)

40

41 instance BlockCipher Blowfish where

58 INSTANCE_CIPHER(Blowfish64, "blowfish64", 8)

59 INSTANCE_CIPHER(Blowfish128, "blowfish128", 16)

60 INSTANCE_CIPHER(Blowfish256, "blowfish256", 32)

61 INSTANCE_CIPHER(Blowfish448, "blowfish448", 56)

62

4 import java.security.SecureRandom;

5

6 import javax.crypto.Cipher;

7 import javax.crypto.KeyGenerator;

8 import javax.crypto.SecretKey;

14 *

15 * <pre>

16 * ?? DES?DESede(TripleDES,??3DES)?AES?Blowfish?RC2?RC4(ARCFOUR)

17 * DES key size must be equal to 56

18 * DESede(TripleDES) key size must be equal to 112 or 168

19 * AES key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available

20 * Blowfish key size must be multiple of 8, and can only range from 32 to 448 (inclusive)

21 * RC2 key size must be between 40 and 1024 bits

22 * RC4(ARCFOUR) key size must be between 40 and 1024 bits

3 import base64

4

5 from Crypto.Cipher import AES, ARC2, Blowfish, CAST, DES, DES3

6 from Crypto.Random import get_random_bytes

7

26 "aes": {"key_sizes": (16, 24, 32), "class": AES},

27 "arc2": {"key_sizes": None, "class": ARC2},

28 "blowfish": {"key_sizes": None, "class": Blowfish},

29 "cast": {"key_sizes": None, "class": CAST},

30 "des": {"key_sizes": (8,), "class": DES},

27 '''

28

29 from Crypto.Cipher import Blowfish

30 from elixir.statements import Statement

31 from sqlalchemy.orm import MapperExtension, EXT_CONTINUE

40

41 def encrypt_value(value, secret):

42 return Blowfish.new(secret, Blowfish.MODE_CFB) \

43 .encrypt(value).encode('string_escape')

44

45 def decrypt_value(value, secret):

46 return Blowfish.new(secret, Blowfish.MODE_CFB) \

47 .decrypt(value.decode('string_escape'))

48

18 import java.security.interfaces.RSAPrivateKey;

19

20 import javax.crypto.Cipher;

21

22 /**

23 * @author -Wooden-

24 */

25 public final class BlowFishKey extends GameToLoginPacket

26 {

27 private byte[] _key;

28

29 public BlowFishKey(byte[] decrypt, RSAPrivateKey privateKey)

30 {

31 super(decrypt);

8 import urllib2

9

10 from Crypto.Cipher import Blowfish

11

12 log = logging.getLogger( __name__ )

184 utility method to encode ID's

185 """

186 id_cipher = Blowfish.new( config_id_secret )

187 # Convert to string

188 s = str( obj_id )

10 import javax.crypto.spec.SecretKeySpec;

11

12 import org.bouncycastle.crypto.CipherKeyGenerator;

13 import org.bouncycastle.crypto.KeyGenerationParameters;

14 import org.bouncycastle.crypto.generators.DESKeyGenerator;

195

196 /**

197 * Blowfish

198 */

199 public static class Blowfish

200 extends JCEKeyGenerator

201 {

202 public Blowfish()

203 {

204 super("Blowfish", 448, new CipherKeyGenerator());

31 standard and has undergone a fair bit of examination.

32

33 Crypto.Cipher.AES Advanced Encryption Standard

34 Crypto.Cipher.ARC2 Alleged RC2

35 Crypto.Cipher.ARC4 Alleged RC4

36 Crypto.Cipher.Blowfish

37 Crypto.Cipher.CAST

38 Crypto.Cipher.DES The Data Encryption Standard. Very commonly used

39 in the past, but today its 56-bit keys are too small.

40 Crypto.Cipher.DES3 Triple DES.

48 import IronPyCrypto_Cipher_ARC2 as ARC2

49 import IronPyCrypto_Cipher_ARC4 as ARC4

50 import IronPyCrypto_Cipher_Blowfish as Blowfish

51 import IronPyCrypto_Cipher_CAST as CAST

52 import IronPyCrypto_Cipher_DES as DES

5 from time import time

6 from django.conf import settings

7 from Crypto.Cipher import Blowfish

8 from base64 import b64encode, b64decode

9 from django import newforms as forms

11

12 def get_key():

13 cobj = Blowfish.new(settings.SECRET_KEY)

14 text = unicode(time())

15 text += "".join(["_" for i in xrange(8-len(text)%8)])

28 raise ValidationError(_('Incorrect key.'))

29

30 cobj = Blowfish.new(settings.SECRET_KEY)

31 text = cobj.decrypt(b64decode(self.cleaned_data['key'])).rstrip('_')

32 try:

1 import pkg_resources

2 pkg_resources.require( "pycrypto" )

3 from Crypto.Cipher import Blowfish

4

5 def encode_dataset_user( trans, dataset, user ):

13 # Pad to a multiple of 8 with leading "!"

14 user_hash = ( "!" * ( 8 - len( user_hash ) % 8 ) ) + user_hash

15 cipher = Blowfish.new( str( dataset.create_time ) )

16 user_hash = cipher.encrypt( user_hash ).encode( 'hex' )

17 return dataset_hash, user_hash

26 user = None

27 else:

28 cipher = Blowfish.new( str( dataset.create_time ) )

29 user_id = cipher.decrypt( user_hash.decode( 'hex' ) ).lstrip( "!" )

30 user = trans.sa_session.query( trans.app.model.User ).get( int( user_id ) )

7 class Encryption(object):

8 def __init__(self):

9 self.__blowfish = None

10

11 @property

13 if not self.__blowfish:

14 from Crypto.Cipher import Blowfish

15 nics = filter(lambda x: x.startswith("eth") or x.startswith("wlan"), q.system.net.getNics())

16 if not nics:

19 nics.sort()

20 mac = q.system.net.getMacAddress(nics[0])

21 self.__blowfish = Blowfish.new(mac)

22

23 return self.__blowfish

12

13 pkg_resources.require( "pycrypto" )

14 from Crypto.Cipher import Blowfish

15 from Crypto.Util.randpool import RandomPool

16 from Crypto.Util import number

18 def encode_id( config_id_secret, obj_id ):

19 # Utility method to encode ID's

20 id_cipher = Blowfish.new( config_id_secret )

21 # Convert to string

22 s = str( obj_id )

25 import java.security.KeyPairGenerator;

26 import java.security.spec.RSAKeyGenParameterSpec;

27 import javax.crypto.Cipher;

28 import javax.crypto.KeyGenerator;

29 import javax.crypto.SecretKey;

32

33 /**

34 * Key generator. It generates keys or keyPairs for Blowfish and RSA

35 */

36 public class KeyGen

60 log.info("Initializing Key Generator...");

61

62 blowfishKeyGen = KeyGenerator.getInstance("Blowfish");

63

64 KeyPairGenerator rsaKeyPairGenerator = KeyPairGenerator.getInstance("RSA");

59 skey = getRawKey(knumb);

60 skeyString = new String(skey);

61 System.out.println("Blowfish Symmetric key = " + skeyString);

62 }

63 catch (Exception e)

92 SecretKeySpec skeySpec = new SecretKeySpec(raw, "Blowfish");

93 Cipher cipher = Cipher.getInstance("Blowfish");

94 cipher.init(Cipher.DECRYPT_MODE, skeySpec);

95 byte[] decrypted = cipher.doFinal(encrypted);

99 public static void main(String args[])

100 {

101 BlowFishAlgorithm bf = new BlowFishAlgorithm();

102 }

103 }

107 //import sun.misc.BASE64Decoder;

108 //import sun.misc.BASE64Encoder;

109 //public class BlowFishAlgorithm {

110 //

111 // public static void main(String[] args) throws Exception {

1 # -*- coding: utf-8 -*-

2 #

3 # Cipher/Blowfish.py : Blowfish

4 #

5 # ===================================================================

39 >>> key = b'An arbitrarily long key'

40 >>> iv = Random.new().read(bs)

41 >>> cipher = Blowfish.new(key, Blowfish.MODE_CBC, iv)

42 >>> plaintext = b'docendo discimus '

43 >>> plen = bs - divmod(len(plaintext),bs)[1]

46 >>> msg = iv + cipher.encrypt(plaintext + padding)

47

48 .. _Blowfish: http://www.schneier.com/blowfish.html

49

50 :undocumented: __revision__, __package__

55 from Crypto.Cipher import blockalgo

56 from Crypto.Cipher import _Blowfish

57

58 class BlowfishCipher (blockalgo.BlockAlgo):

31 import gnu.javax.crypto.assembly.Transformer;

32 import gnu.javax.crypto.assembly.TransformerException;

33 import gnu.javax.crypto.cipher.Blowfish;

34 import gnu.javax.crypto.cipher.IBlockCipher;

64 TestOfAssembly testcase = new TestOfAssembly();

65

66 // build an OFB-Blowfish cascade

67 Cascade ofbBlowfish = new Cascade();

68 Object modeNdx = ofbBlowfish.append(Stage.getInstance(

69 ModeFactory.getInstance(

70 Registry.OFB_MODE, new Blowfish(), 8),

76

77 testcase.asm = new Assembly();

78 testcase.asm.addPreTransformer(Transformer.getCascadeTransformer(ofbBlowfish));

79 testcase.asm.addPreTransformer(Transformer.getPaddingTransformer(pkcs7));

80

20 import java.security.spec.RSAKeyGenParameterSpec;

21

22 import javax.crypto.Cipher;

23 import javax.crypto.KeyGenerator;

24 import javax.crypto.SecretKey;

28

29 /**

30 * Key generator. It generates keys or keyPairs for Blowfish and RSA

31 */

32

57 log.info("Iniciando el generador de claves de acceso..");

58

59 blowfishKeyGen = KeyGenerator.getInstance("Blowfish");

60

61 KeyPairGenerator rsaKeyPairGenerator = KeyPairGenerator.getInstance("RSA");

1 Name: cipher-blowfish

2 Version: 0.0.3

3 Description: Blowfish cipher primitives

7 Author: Vincent Hanquez <vincent@snarc.org>

8 Maintainer: Vincent Hanquez <vincent@snarc.org>

9 Synopsis: Blowfish cipher

10 Category: Cryptography

11 Build-Type: Simple

20 , securemem >= 0.1.2

21 , crypto-cipher-types >= 0.0.3 && < 0.1

22 Exposed-modules: Crypto.Cipher.Blowfish

23 Other-modules: Crypto.Cipher.Blowfish.Primitive

24 ghc-options: -Wall -optc-O3 -fno-cse -fwarn-tabs

25

26 Test-Suite test-cipher-blowfish

27 type: exitcode-stdio-1.0

28 hs-source-dirs: Tests

17 * under the License.

18 */

19 package org.apache.shiro.crypto.cipher;

20

21 /**

22 * {@code CipherService} using the {@code Blowfish} cipher algorithm for all encryption, decryption, and key operations.

23 * <p/>

24 * The Blowfish algorithm can support key sizes between {@code 32} and {@code 448} bits<b>*</b>, inclusive. However,

33 * used in this implementation.

34 * <p/>

35 * <b>*</b> Generating and using Blowfish key sizes greater than 128 require installation of the

36 * <a href="http://java.sun.com/javase/downloads/index.jsp">Java Cryptography Extension (JCE) Unlimited Strength

37 * Jurisdiction Policy files</a>.

1 package org.bouncycastle.jcajce.provider.symmetric;

2

3 import org.bouncycastle.crypto.CipherKeyGenerator;

4 import org.bouncycastle.crypto.engines.BlowfishEngine;

10 import org.bouncycastle.jcajce.provider.util.AlgorithmProvider;

11

12 public final class Blowfish

13 {

14 private Blowfish()

21 public ECB()

22 {

23 super(new BlowfishEngine());

24 }

25 }

30 public CBC()

31 {

32 super(new CBCBlockCipher(new BlowfishEngine()), 64);

33 }

34 }

19 , cipher-rc4 >= 0.1.3 && < 0.2

20 , cipher-des >= 0.0 && < 0.1

21 , cipher-blowfish >= 0.0 && < 0.1

22 , cipher-camellia >= 0.0 && < 0.1

23 Exposed-modules: Crypto.Cipher

24 randompool = None

25 if hasCrypto:

26 from Crypto.Cipher import Blowfish

27 from Crypto.Util.randpool import RandomPool

28 randompool = RandomPool(500)

45 key = privatekeys[config.serverhostname].decrypt(key)

46 s = decodestring(data)

47 b = Blowfish.new(key, Blowfish.MODE_CBC)

48 s = b.decrypt(s)

49 s = decompress(s)

59 if not hasattr(request, '_my_secret'):

60 request._my_secret = genPassword()

61 b = Blowfish.new(request._my_secret, Blowfish.MODE_CBC)

62 res = b.encrypt(res+' '*(8-len(res)%8))

63 return encodestring(res)

11 import com.gemstone.gemfire.internal.i18n.LocalizedStrings;

12

13 import javax.crypto.Cipher;

14 import javax.crypto.spec.SecretKeySpec;

15

16 /**

17 * Generates an encrypted password, used by the gemfire encrypt-password

18 * command. Makes use of Blowfish algorithm to encrypt/decrypt password string

19 *

20 * <p>

61 String encryptedString = null;

62 try {

63 SecretKeySpec key = new SecretKeySpec(init, "Blowfish");

64 Cipher cipher = Cipher.getInstance("Blowfish");

88 try {

89 String toDecrypt = password.substring(10, password.length() - 1);

90 SecretKeySpec key = new SecretKeySpec(init, "Blowfish");

91 Cipher cipher = Cipher.getInstance("Blowfish");

15

16 # From the python-crypto package

17 from Crypto.Cipher import Blowfish

18

19

95 Uses the Blowfish algorithm. Plaintext will be padded if required.

96 """

97 obj = Blowfish.new(key, Blowfish.MODE_CBC)

98

99 plaintext = pad(plaintext)

108 Uses the Blowfish algorithm. Padding bytes (if present) will be removed.

109 """

110 obj = Blowfish.new(key, Blowfish.MODE_CBC)

111 decrypted_plaintext = obj.decrypt(ciphertext)

112 return_me = unpad(decrypted_plaintext)

1 package org.spongycastle.jcajce.provider.symmetric;

2

3 import org.spongycastle.crypto.CipherKeyGenerator;

4 import org.spongycastle.crypto.engines.BlowfishEngine;

10 import org.spongycastle.jcajce.provider.util.AlgorithmProvider;

11

12 public final class Blowfish

13 {

14 private Blowfish()

21 public ECB()

22 {

23 super(new BlowfishEngine());

24 }

25 }

30 public CBC()

31 {

32 super(new CBCBlockCipher(new BlowfishEngine()), 64);

33 }

34 }

34 , tagged

35 , cereal

36 Exposed-modules: Crypto.Cipher.RC4

37 Crypto.Cipher.AES

38 Crypto.Cipher.AES.Haskell

39 Crypto.Cipher.Blowfish

40 Crypto.Cipher.Camellia

41 Crypto.Cipher.RSA

42 Crypto.Cipher.DSA

43 Crypto.Cipher.DH

44 other-modules: Number.ModArithmetic

45 Number.Serialize

48 Number.Polynomial

49 Number.Prime

50 Crypto.Cipher.ElGamal

51 ghc-options: -Wall

52 if flag(aesni)

26

27 try:

28 from Crypto.Cipher import Blowfish

29 hasCrypto = 1

30 except ImportError: hasCrypto = 0

63 data = dumps((method, args, kw))

64 data = compress(data)

65 b = Blowfish.new(obj.secret, Blowfish.MODE_CBC)

66 data = b.encrypt(data+' '*(8-len(data)%8))

67 data = encodestring(data)

75 def parse_response(self, data, obj):

76 data = decodestring(data)

77 b = Blowfish.new(obj.secret, Blowfish.MODE_CBC)

78 data = b.decrypt(data)

79 data = decompress(data)

40

41 import gnu.java.security.Registry;

42 import gnu.javax.crypto.cipher.CipherFactory;

43 import gnu.javax.crypto.mac.MacFactory;

44

73 gnu.javax.crypto.jce.cipher.ARCFourSpi.class.getName());

74 put("Cipher.ARCFOUR ImplementedIn", "Software");

75 put("Cipher.BLOWFISH",

76 gnu.javax.crypto.jce.cipher.BlowfishSpi.class.getName());

77 put("Cipher.BLOWFISH ImplementedIn", "Software");

78 put("Cipher.DES", gnu.javax.crypto.jce.cipher.DESSpi.class.getName());

79 put("Cipher.DES ImplementedIn", "Software");

111 put("Cipher.PBEWithHMacHavalAndAnubis",

112 gnu.javax.crypto.jce.cipher.PBES2.HMacHaval.Anubis.class.getName());

113 put("Cipher.PBEWithHMacHavalAndBlowfish",

114 gnu.javax.crypto.jce.cipher.PBES2.HMacHaval.Blowfish.class.getName());

9 import java.security.Provider;

10

11 import javax.crypto.Cipher;

12 import javax.crypto.spec.SecretKeySpec;

13

21 * @author pippo

22 */

23 public class BlowfishEncryptor implements Encryptor {

24

25 // private static Logger logger = LoggerFactory.getLogger(BlowfishEncryptor.class);

87 // System.out.println((byte) 0);

88 //

89 // BlowfishEncryptor encryptor = new BlowfishEncryptor();

90 //

91 // String target = "1234567812345678344dfsdsrerwerwer123";

7 pkg_resources.require( "pycrypto" )

8

9 from Crypto.Cipher import Blowfish

10 from Crypto.Util.randpool import RandomPool

11 from Crypto.Util import number

40 def __init__( self, **config ):

41 self.id_secret = config['id_secret']

42 self.id_cipher = Blowfish.new( self.id_secret )

43

44 per_kind_id_secret_base = config.get( 'per_kind_id_secret_base', self.id_secret )

127

128 def __missing__( self, key ):

129 return Blowfish.new( self.secret_base + "__" + key )

130

1 from Crypto.Cipher import Blowfish

2

3

12 # Pad to a multiple of 8 with leading "!"

13 user_hash = ( "!" * ( 8 - len( user_hash ) % 8 ) ) + user_hash

14 cipher = Blowfish.new( str( dataset.create_time ) )

15 user_hash = cipher.encrypt( user_hash ).encode( 'hex' )

16 return dataset_hash, user_hash

26 user = None

27 else:

28 cipher = Blowfish.new( str( dataset.create_time ) )

29 user_id = cipher.decrypt( user_hash.decode( 'hex' ) ).lstrip( "!" )

30 user = trans.sa_session.query( trans.app.model.User ).get( int( user_id ) )

24 import java.io.FileOutputStream;

25

26 import javax.crypto.Cipher;

27 import javax.crypto.CipherOutputStream;

35 {

36 private static final String PASS_PHRASE = "XerelaPassPhrase";

37 private static final String ALGORITHM = "Blowfish";

38

39 /**

5 import java.security.spec.RSAKeyGenParameterSpec;

6

7 import javax.crypto.Cipher;

8 import javax.crypto.KeyGenerator;

9 import javax.crypto.SecretKey;

15

16 /**

17 * Key generator. It generates keys or keyPairs for Blowfish and RSA

18 *

19 * @author -Nemesiss-

46 log.info("Initializing Key Generator...");

47

48 blowfishKeyGen = KeyGenerator.getInstance("Blowfish");

49

50 KeyPairGenerator rsaKeyPairGenerator = KeyPairGenerator.getInstance("RSA");

15 eggs.require( "pycrypto" )

16

17 from Crypto.Cipher import Blowfish

18

19 log = logging.getLogger( __name__ )

189 utility method to encode ID's

190 """

191 id_cipher = Blowfish.new( config_id_secret )

192 # Convert to string

193 s = str( obj_id )

33 import javax.crypto.spec.*;

34

35 public class BlowfishCBC implements Cipher{

36 private static final int ivsize=8;

37 private static final int bsize=16;

38 private javax.crypto.Cipher cipher;

39 public int getIVSize(){return ivsize;}

40 public int getBlockSize(){return bsize;}

56 SecretKeySpec skeySpec = new SecretKeySpec(key, "Blowfish");

57 cipher=javax.crypto.Cipher.getInstance("Blowfish/CBC/"+pad);

58 cipher.init((mode==ENCRYPT_MODE?

59 javax.crypto.Cipher.ENCRYPT_MODE:

60 javax.crypto.Cipher.DECRYPT_MODE),

61 skeySpec, new IvParameterSpec(iv));

62 }

18 import java.security.interfaces.RSAPublicKey;

19

20 import javax.crypto.Cipher;

21

22 /**

25 public final class BlowFishKey extends GameServerBasePacket

26 {

27 public BlowFishKey(byte[] blowfishKey, RSAPublicKey publicKey)

28 {

29 super(0x00);

33 Cipher rsaCipher = Cipher.getInstance("RSA/ECB/nopadding");

34 rsaCipher.init(Cipher.ENCRYPT_MODE, publicKey);

35 encrypted = rsaCipher.doFinal(blowfishKey);

36

37 writeD(encrypted.length);

1 Index: Blowfish.js

2 ===================================================================

3 --- Blowfish.js (revision 15563)

4 +++ Blowfish.js (working copy)

5 @@ -343,14 +343,14 @@

6 var cipher=[], count=plaintext.length >> 3, pos=0, o={}, isCBC=(mode==dojox.encoding.crypto.cipherModes.CBC);

14 import qualified Data.ByteString.Lazy as L

15

16 import qualified Crypto.Cipher.AES.Haskell as AES

17 #ifdef HAVE_AESNI

18 import qualified Crypto.Cipher.AES.X86NI as AESNI

20 import qualified Crypto.Cipher.RC4 as RC4

21 import qualified Crypto.Cipher.Blowfish as Blowfish

22 import qualified Crypto.Cipher.Camellia as Camellia

48 (Right blowfishKey) = Blowfish.initKey $ B.empty

49 blowfishEncrypt = Blowfish.encrypt blowfishKey

50

51 (Right camelliaKey128) = Camellia.initKey128 $ B.replicate 16 0

94 l <- mapM (doOne env)

95 [ ("RC4" , rc4Encrypt)

96 , ("Blowfish" , blowfishEncrypt)

97 , ("Camellia128", camelliaEncrypt128)

98 , ("AES128" , aesEncrypt128)

23 import java.util.logging.Logger;

24

25 import javax.crypto.Cipher;

26

27 import com.l2jserver.util.network.BaseSendablePacket;

30 * @author -Wooden-

31 */

32 public class BlowFishKey extends BaseSendablePacket

33 {

34 private static Logger _log = Logger.getLogger(BlowFishKey.class.getName());

38 * @param publicKey

39 */

40 public BlowFishKey(byte[] blowfishKey, RSAPublicKey publicKey)

41 {

42 writeC(0x00);

1 import pkg_resources

2 pkg_resources.require( "pycrypto" )

3 from Crypto.Cipher import Blowfish

4

5 def encode_dataset_user( trans, dataset, user ):

13 # Pad to a multiple of 8 with leading "!"

14 user_hash = ( "!" * ( 8 - len( user_hash ) % 8 ) ) + user_hash

15 cipher = Blowfish.new( str( dataset.create_time ) )

16 user_hash = cipher.encrypt( user_hash ).encode( 'hex' )

17 return dataset_hash, user_hash

26 user = None

27 else:

28 cipher = Blowfish.new( str( dataset.create_time ) )

29 user_id = cipher.decrypt( user_hash.decode( 'hex' ) ).lstrip( "!" )

30 user = trans.sa_session.query( trans.app.model.User ).get( int( user_id ) )

4 """

5

6 from Crypto.Cipher import Blowfish

7 from datetime import datetime

8 from decimal import Decimal

110 def _decrypt_code(code):

111 """Decrypt code encrypted by _encrypt_code"""

112 # In some blowfish implementations, > 56 char keys can cause problems

113 secret_key = settings.SECRET_KEY[:56]

114 encryption_object = Blowfish.new(secret_key)

118 def _encrypt_code(code):

119 """Quick encrypter for CC codes or code fragments"""

120 # In some blowfish implementations, > 56 char keys can cause problems

121 secret_key = settings.SECRET_KEY[:56]

122 encryption_object = Blowfish.new(secret_key)

2 import django.contrib.contenttypes.models

3 from django.contrib import contenttypes

4 from Crypto.Cipher import Blowfish

5 from base64 import *

6 import random

22

23 def cryptString( plain ):

24 obj=Blowfish.new( settings.SECRET_KEY, Blowfish.MODE_ECB)

25 randstring = open("/dev/urandom").read(12)

26 split = random.randrange(10)+1

38

39 def decryptString( cipher ):

40 obj=Blowfish.new( settings.SECRET_KEY, Blowfish.MODE_ECB)

41 try:

42 ciph = b32decode( cipher )

8 import os.path

9 import ConfigParser

10 from Crypto.Cipher import Blowfish, AES

11 import secret_key

12 from pim_errors import InvalidOptionValueError

28 default = {}

29 default['keyring'] = 'user'

30 default['algorithm'] = 'Blowfish'

31 return default

32

57

58 alg = config.get('Cryptography', 'algorithm')

59 if alg == 'Blowfish':

60 CipherAlgorithm = Blowfish

78 keyring = keyring

79 # Encryption algorithm to use.

80 # Possible values: Blowfish, AES

81 algorithm = Blowfish

37

38

39 package gnu.javax.crypto.cipher;

40

41 import gnu.java.security.Registry;

74 if (name.equalsIgnoreCase(ANUBIS_CIPHER))

75 result = new Anubis();

76 else if (name.equalsIgnoreCase(BLOWFISH_CIPHER))

77 result = new Blowfish();

115 HashSet hs = new HashSet();

116 hs.add(ANUBIS_CIPHER);

117 hs.add(BLOWFISH_CIPHER);

118 hs.add(DES_CIPHER);

119 hs.add(KHAZAD_CIPHER);

26 import java.util.Properties;

27

28 import javax.crypto.Cipher;

29 import javax.crypto.CipherInputStream;

39 {

40 private static final String PASS_PHRASE = "XerelaPassPhrase";

41 private static final String ALGORITHM = "Blowfish";

42 private static License license;

43

30 import org.apache.shiro.SecurityUtils;

31 import org.apache.shiro.aop.DefaultAnnotationResolver;

32 import org.apache.shiro.crypto.cipher.BlowfishCipherService;

33 import org.apache.shiro.guice.aop.ShiroAopModule;

34 import org.apache.shiro.guice.web.ShiroWebModule;

69 assertTrue(BeanTypeListener.MATCHER.matches(TypeLiteral.get(SecurityUtils.class)));

70 assertTrue(BeanTypeListener.MATCHER.matches(TypeLiteral.get(DefaultAnnotationResolver.class)));

71 assertTrue(BeanTypeListener.MATCHER.matches(TypeLiteral.get(BlowfishCipherService.class)));

72 }

73

6

7 import javax.crypto.BadPaddingException;

8 import javax.crypto.Cipher;

9 import javax.crypto.IllegalBlockSizeException;

10 import javax.crypto.NoSuchPaddingException;

14

15 public class EncryptUtil {

16 private static final String ALGORITHM = "Blowfish";

17

18 public static String encrypt(String key, String text)

7 """

8

9 from Crypto.Cipher import Blowfish

10 import crack

11 import pickle

32

33 def _encrypt(encryption_key, string):

34 cipher_obj = Blowfish.new(encryption_key)

35 return cipher_obj.encrypt(string)

36

37 def _decrypt(encryption_key, string):

38 cipher_obj = Blowfish.new(encryption_key)

39 return cipher_obj.decrypt(string)

40

36 "com.trilead.ssh2.crypto.cipher.AES"));

37 ciphers.addElement(new CipherEntry("aes128-cbc", 16, 16,

38 "com.trilead.ssh2.crypto.cipher.AES"));

39 ciphers.addElement(new CipherEntry("blowfish-cbc", 8, 16,

40 "com.trilead.ssh2.crypto.cipher.BlowFish"));

41

42 ciphers.addElement(new CipherEntry("aes256-ctr", 16, 32,

43 "com.trilead.ssh2.crypto.cipher.AES"));

44 ciphers.addElement(new CipherEntry("aes192-ctr", 16, 24,

45 "com.trilead.ssh2.crypto.cipher.AES"));

48 ciphers.addElement(new CipherEntry("blowfish-ctr", 8, 16,

49 "com.trilead.ssh2.crypto.cipher.BlowFish"));

50

51 ciphers.addElement(new CipherEntry("3des-ctr", 8, 24,

36 from Crypto.Cipher import AES as _AES

37 from Crypto.Cipher import Blowfish as _Blowfish

38 from Crypto.Cipher import CAST as _CAST

39 from Crypto.Cipher import DES as _DES

40 from Crypto.Cipher import DES3 as _DES3

46 name = cipher.__name__.split('.')[-1]

47 part.__name__ = name.lower()

48 part.__module__ = b'lck.crypto.cipher'

49 part.__doc__ = ("{}([key, path, create]) -> Cipher instance\n\nFactory "

50 "creating a cipher using the {} algorithm. Arguments have the same "

54

55 aes = _setup_cipher(_AES)

56 blowfish = _setup_cipher(_Blowfish)

57 cast = _setup_cipher(_CAST)

58 des = _setup_cipher(_DES)

4

5

6 from Crypto.Cipher import Blowfish

7 from base64 import *

8 import random

11

12 def cryptString( secret, plain ):

13 obj = Blowfish.new( secret, Blowfish.MODE_ECB )

14 #randstring = unicode(open("/dev/urandom").read(12), 'ascii', 'ignore')

15 randstring = str.join( '', random.sample('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890',12) )

29

30 def decryptString( secret, cipher ):

31 obj = Blowfish.new( secret, Blowfish.MODE_ECB )

32 try:

33 ciph = b32decode( cipher )

1 package gnu.crypto.cipher;

2

3 // ----------------------------------------------------------------------------

90 if (name.equalsIgnoreCase(ANUBIS_CIPHER)) {

91 result = new Anubis();

92 } else if (name.equalsIgnoreCase(BLOWFISH_CIPHER)) {

93 result = new Blowfish();

132 HashSet hs = new HashSet();

133 hs.add(ANUBIS_CIPHER);

134 hs.add(BLOWFISH_CIPHER);

135 hs.add(DES_CIPHER);

136 hs.add(KHAZAD_CIPHER);

23 import java.util.logging.Logger;

24

25 import javax.crypto.Cipher;

26

27 import com.l2jserver.Config;

34 * @author -Wooden-

35 */

36 public class BlowFishKey extends BaseRecievePacket

37 {

38 protected static final Logger _log = Logger.getLogger(BlowFishKey.class.getName());

42 * @param server

43 */

44 public BlowFishKey(byte[] decrypt, GameServerThread server)

45 {

46 super(decrypt);

1

2 package com.trilead.ssh2.crypto.cipher;

3

4 import java.util.Vector;

34 /* Higher Priority First */

35

36 ciphers.addElement(new CipherEntry("aes256-ctr", 16, 32, "com.trilead.ssh2.crypto.cipher.AES"));

37 ciphers.addElement(new CipherEntry("aes192-ctr", 16, 24, "com.trilead.ssh2.crypto.cipher.AES"));

38 ciphers.addElement(new CipherEntry("aes128-ctr", 16, 16, "com.trilead.ssh2.crypto.cipher.AES"));

39 ciphers.addElement(new CipherEntry("blowfish-ctr", 8, 16, "com.trilead.ssh2.crypto.cipher.BlowFish"));

40

41 ciphers.addElement(new CipherEntry("aes256-cbc", 16, 32, "com.trilead.ssh2.crypto.cipher.AES"));

43 ciphers.addElement(new CipherEntry("aes128-cbc", 16, 16, "com.trilead.ssh2.crypto.cipher.AES"));

44 ciphers.addElement(new CipherEntry("blowfish-cbc", 8, 16, "com.trilead.ssh2.crypto.cipher.BlowFish"));

45

46 ciphers.addElement(new CipherEntry("3des-ctr", 8, 24, "com.trilead.ssh2.crypto.cipher.DESede"));

2

3 // CIPHER / GENERATORS

4 import javax.crypto.Cipher;

5 import javax.crypto.SecretKey;

6

21 * ----------------------------------------------------------------------------- The following example implements a class for encrypting and decrypting strings

22 * using several Cipher algorithms. The class is created with a key and can be used repeatedly to encrypt and decrypt strings using that key. Some of the more

23 * popular algorithms are: Blowfish DES DESede PBEWithMD5AndDES PBEWithMD5AndTripleDES TripleDES

24 *

25 * @version 1.0

4 """

5

6 from Crypto.Cipher import Blowfish

7 from datetime import datetime

8 from django.conf import settings

114 """Decrypt code encrypted by _encrypt_code"""

115 secret_key = settings.SECRET_KEY

116 encryption_object = Blowfish.new(secret_key)

117 # strip padding from decrypted credit card number

118 return encryption_object.decrypt(base64.b64decode(code)).rstrip('X')

121 """Quick encrypter for CC codes or code fragments"""

122 secret_key = settings.SECRET_KEY

123 encryption_object = Blowfish.new(secret_key)

124 # block cipher length must be a multiple of 8

125 padding = ''

6 import java.util.Iterator;

7

8 import javax.crypto.Cipher;

9 import javax.crypto.CipherOutputStream;

23 public final class BlowfishCrypt {

24 private static final BlowfishCrypt instance = new BlowfishCrypt();

25

26 private BlowfishCrypt() {

68

69 private byte[] crypt(byte[] input, byte[] key, int mode) throws Exception {

70 SecretKeySpec skeySpec = new SecretKeySpec(key, "Blowfish");

71 IvParameterSpec ivSpec = new IvParameterSpec(deriveIv(key));

72 Cipher cipher = Cipher.getInstance("Blowfish/CBC/PKCS5Padding");

122 }

123

124 public static BlowfishCrypt getInstance() {

125 return BlowfishCrypt.instance;

1 package com.anyoption.common.util;

2

3 import javax.crypto.Cipher;

4 import javax.crypto.spec.SecretKeySpec;

5

26

27 private static byte[] encrypt(byte[] input, byte[] key) throws Exception {

28 Cipher cipher = Cipher.getInstance("Blowfish/ECB/PKCS5Padding");

29 SecretKeySpec keySpec = new SecretKeySpec(key, "Blowfish");

33

34 private static byte[] decrypt(byte[] input, byte[] key) throws Exception {

35 Cipher cipher = Cipher.getInstance("Blowfish/ECB/PKCS5Padding");

36 SecretKeySpec keySpec = new SecretKeySpec(key, "Blowfish");

11

12 /**

13 * ??Blowfish?????????

14 *

15 */

16 public class BlowfishEncrypter {

17 /** logger */

18 private static final Logger logger = Logger.getLogger(BlowfishEncrypter.class);

21 private static String CIPHER_NAME = "Blowfish/CFB8/NoPadding";

22 private static String KEY_SPEC_NAME = "Blowfish";

23 private static String CHARSET = "GBK";

24

66 public static BlowfishEncrypter getEncrypter() {

67 BlowfishEncrypter encrypter = (BlowfishEncrypter) encrypter_pool.get();

68

69 if (encrypter == null) {

13

14 import javax.crypto.BadPaddingException;

15 import javax.crypto.Cipher;

16 import javax.crypto.IllegalBlockSizeException;

17 import javax.crypto.KeyGenerator;

43 {

44 /*

45 "ArcFour", "BlowfishKey", "CAST256",

46 "CAST", "DES2", "DESede", "DES", "Rijndael", "Serpent", "Twofish"

47 */

4 """

5

6 from Crypto.Cipher import Blowfish

7 from datetime import datetime

8 from django.conf import settings

65 # Must remember to save it after calling!

66 secret_key = settings.SECRET_KEY

67 encryption_object = Blowfish.new(secret_key)

68 # block cipher length must be a multiple of 8

69 padding = ''

92 def _decryptCC(self):

93 secret_key = settings.SECRET_KEY

94 encryption_object = Blowfish.new(secret_key)

95 # strip padding from decrypted credit card number

96 ccnum = encryption_object.decrypt(base64.b64decode(self.encrypted_cc)).rstrip('X')

14

15 import javax.crypto.BadPaddingException;

16 import javax.crypto.Cipher;

17 import javax.crypto.CipherInputStream;

22 public class CipherUtils

23 {

24 private static String algo = "Blowfish";

25

26 /**

11 standard and has undergone a fair bit of examination.

12

13 Crypto.Cipher.AES Advanced Encryption Standard

14 Crypto.Cipher.ARC2 Alleged RC2

15 Crypto.Cipher.ARC4 Alleged RC4

16 Crypto.Cipher.Blowfish

17 Crypto.Cipher.CAST

18 Crypto.Cipher.DES The Data Encryption Standard. Very commonly used

19 in the past, but today its 56-bit keys are too small.

20 Crypto.Cipher.DES3 Triple DES.

21 Crypto.Cipher.IDEA

22 Crypto.Cipher.RC5

23 Crypto.Cipher.XOR The simple XOR cipher.

24 """

25

10 import java.util.Map;

11

12 import javax.crypto.Cipher;

13 import javax.crypto.KeyGenerator;

14 import javax.crypto.SecretKey;

43

44 // Create the secret/symmetric key

45 KeyGenerator kgen = KeyGenerator.getInstance("Blowfish");

46 SecretKey skey = kgen.generateKey();

47 byte[] raw = skey.getEncoded();

48 SecretKeySpec skeySpec = new SecretKeySpec(raw, "Blowfish");

49

50 // Create the cipher for encrypting

1 package com.edd.rubicon.service;

2 import javax.crypto.Cipher;

3 import javax.crypto.spec.SecretKeySpec;

4 import org.apache.tomcat.util.codec.binary.Base64;

21

22 /**

23 * Encrypts the given text using the key passed into the constructor, uses Blowfish

24 * encryption

25 * @precondition strClearText is not null

31 String str = "";

32 try {

33 SecretKeySpec skeyspec=new SecretKeySpec(strKey.getBytes(),"Blowfish");

34 Cipher cipher=Cipher.getInstance("Blowfish");

54 String strData="";

55 try {

56 SecretKeySpec skeyspec=new SecretKeySpec(strKey.getBytes(),"Blowfish");

57 Cipher cipher=Cipher.getInstance("Blowfish");

12

13 pkg_resources.require( "pycrypto" )

14 from Crypto.Cipher import Blowfish

15 from Crypto.Util.randpool import RandomPool

16 from Crypto.Util import number

163 # utility method to encode ID's

164 def encode_id( config_id_secret, obj_id ):

165 id_cipher = Blowfish.new( config_id_secret )

166 # Convert to string

167 s = str( obj_id )

5 import tempfile

6 import json

7 from Crypto.Cipher import AES, Blowfish

8 import secret_key

9 import settings

17 class TestEncryption(unittest.TestCase):

18

19 def test_blowfish_encryption(self):

20 settings.CipherAlgorithm = Blowfish

48

49 def test_enc_getter(self):

50 c = crypto.Cipher(secret_key.get_key_dummy())

51 e = c.encrypt(self.value)

52 i = info.InfoItem(u'name', e)

54

55 def test_enc_setter(self):

56 c = crypto.Cipher(secret_key.get_key_dummy())

57 e = c.encrypt(u'dummy')

58 i = info.InfoItem(u'name', e)

1 import base64

2 from Crypto.Cipher import Blowfish

3 from Crypto.Hash import SHA256

4

5 class Crypt:

6 """Crypto cipher to make it easier to encrypt and decrypt using Blowfish.

7 This module also works with qrypto perl and PHP modules"""

8

16 def decrypt(self, encrypted_encoded):

17 decoded = base64.b64decode(encrypted_encoded)

18 crypto = Blowfish.new(self.__key, Blowfish.MODE_CBC, self.__iv)

19 return self.__trim(crypto.decrypt(decoded))

20

21 def encrypt(self, plain_text):

22 padded = self.__pad(plain_text)

23 crypto = Blowfish.new(self.__key, Blowfish.MODE_CBC, self.__iv)

24 encrypted = crypto.encrypt(padded)

25 return base64.b64encode(encrypted)

16 import java.security.cert.CertificateFactory;

17

18 import javax.crypto.Cipher;

19 import javax.crypto.KeyGenerator;

20 import javax.crypto.SecretKey;

51

52 public static void encrypt() throws Exception{

53 KeyGenerator kgen = KeyGenerator.getInstance("Blowfish");

54 SecretKey skey = kgen.generateKey();

55 byte[] raw = skey.getEncoded();

56 SecretKeySpec skeySpec = new SecretKeySpec(raw, "Blowfish");

57

58 // Create the cipher for encrypting

21 import org.apache.log4j.Logger;

22

23 import javax.crypto.Cipher;

24 import javax.crypto.KeyGenerator;

25 import javax.crypto.SecretKey;

29

30 /**

31 * Key generator. It generates keys or keyPairs for Blowfish and RSA

32 *

33 * @author -Nemesiss-

60 log.info("Initializing Key Generator...");

61

62 blowfishKeyGen = KeyGenerator.getInstance("Blowfish");

63

64 KeyPairGenerator rsaKeyPairGenerator = KeyPairGenerator.getInstance("RSA");

4 """

5

6 from Crypto.Cipher import Blowfish

7 from django.conf import settings

8 from django.db import models

58 # Must remember to save it after calling!

59 secret_key = settings.SECRET_KEY

60 encryption_object = Blowfish.new(secret_key)

61 # block cipher length must be a multiple of 8

62 padding = ''

68 def _decryptCC(self):

69 secret_key = settings.SECRET_KEY

70 encryption_object = Blowfish.new(secret_key)

71 # strip padding from decrypted credit card number

72 ccnum = encryption_object.decrypt(base64.b64decode(self.encryptedCC)).rstrip('X')

29 import java.util.Iterator;

30

31 import javax.crypto.Cipher;

32 import javax.crypto.KeyGenerator;

33 import javax.crypto.SealedObject;

56 }

57

58 static void testBlowfish() throws Exception

59 {

60 KeyGenerator kgen = KeyGenerator.getInstance("Blowfish");

61 Cipher cipher = Cipher.getInstance("Blowfish");

62 SecretKey key = null;

63 int minKeyBits = -1, maxKeyBits = 0;

96 {

97 int size = 8 * 24;

98 KeyGenerator kgen = KeyGenerator.getInstance("Blowfish");

99 kgen.init(size);

100 SecretKey key = kgen.generateKey();

1 package com.trilead.ssh2.crypto.cipher;

2

3 import java.security.SecureRandom;

4 import javax.crypto.Cipher;

5 import javax.crypto.spec.IvParameterSpec;

6 import javax.crypto.spec.SecretKeySpec;

27 } else if (cipherName.startsWith("3des")){

28 algorithm = "DESede";

29 } else if (cipherName.startsWith("blowfish")){

30 algorithm = "Blowfish";

75

76 @Test

77 public void testMatchBehaviorBlowfishCtrNoPaddingg() throws Exception {

78 shouldMatchJreBehavior("blowfish-ctr", 8, 16);

31 standard and has undergone a fair bit of examination.

32

33 Crypto.Cipher.AES Advanced Encryption Standard

34 Crypto.Cipher.ARC2 Alleged RC2

35 Crypto.Cipher.ARC4 Alleged RC4

36 Crypto.Cipher.Blowfish

37 Crypto.Cipher.CAST

38 Crypto.Cipher.DES The Data Encryption Standard. Very commonly used

39 in the past, but today its 56-bit keys are too small.

40 Crypto.Cipher.DES3 Triple DES.

41 Crypto.Cipher.XOR The simple XOR cipher.

42 """

43

23 import java.security.Key;

24

25 import javax.crypto.Cipher;

26 import javax.crypto.spec.SecretKeySpec;

27

34 public enum CryptoAlgorithm

35 {

36 DES, BLOWFISH;

37 }

38

50 * @throws Exception

51 */

52 public static String encrypt(final String source, final CryptoAlgorithm algorithm, final String blowfishKey) throws Exception

53 {

54

40 Module name Type Description

41 ======================== ======= ========================

42 `Crypto.Cipher.AES` Block Advanced Encryption Standard

43 `Crypto.Cipher.ARC2` Block Alleged RC2

44 `Crypto.Cipher.ARC4` Stream Alleged RC4

45 `Crypto.Cipher.Blowfish` Block Blowfish

46 `Crypto.Cipher.CAST` Block CAST

47 `Crypto.Cipher.DES` Block The Data Encryption Standard.

48 Very commonly used in the past,

49 but today its 56-bit keys are too small.

50 `Crypto.Cipher.DES3` Block Triple DES.

51 `Crypto.Cipher.XOR` Stream The simple XOR cipher.

1 # -*- coding: utf-8 -*-

2 import binascii

3 from Crypto.Cipher import Blowfish

4

5 from django.conf import settings

121 if not self.encrypted_password:

122 return u""

123 enc_obj = Blowfish.new(settings.SECRET_KEY)

124 hex_password = binascii.a2b_hex(self.encrypted_password)

125 return u"%s" % enc_obj.decrypt(hex_password).rstrip()

129 self.encrypted_password = u""

130 else:

131 enc_obj = Blowfish.new(settings.SECRET_KEY)

132 repeat = 8 - (len(value) % 8)

133 value = value + " " * repeat

15 import java.util.logging.Logger;

16 import javax.crypto.BadPaddingException;

17 import javax.crypto.Cipher;

18 import javax.crypto.IllegalBlockSizeException;

19 import javax.crypto.NoSuchPaddingException;

26 * @author Milan

27 */

28 public class BlowFish implements Blender{

29 private static final String TAG = "Blowfish : ";

32

33

34 public BlowFish(){

35 try {

36 cipher = Cipher.getInstance("Blowfish");

37 } catch (NoSuchAlgorithmException | NoSuchPaddingException ex) {

38 Logger.getLogger(BlowFish.class.getName()).log(Level.SEVERE, null, ex);

39 }

40 }

29 alg = Cipher.Algorithm.javaToOssl("RC2/CFB/PKCS5Padding", 40);

30 assertEquals("RC2-40-CFB", alg);

31 alg = Cipher.Algorithm.javaToOssl("Blowfish", 60);

32 assertEquals("BF-60-CBC", alg);

33 alg = Cipher.Algorithm.javaToOssl("DESede", 24);

105 alg = Cipher.Algorithm.osslToJava("BF");

106 assertEquals("BF", alg.base);

107 assertEquals("Blowfish/CBC/PKCS5Padding", alg.getRealName());

108

109 alg = Cipher.Algorithm.osslToJava("AES-128-XTS");

195 @Test

196 public void getAlgorithmBase() throws Exception {

197 javax.crypto.Cipher cipher; String algBase;

198 cipher = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");

200 assertEquals("DES", algBase);

201

202 cipher = javax.crypto.Cipher.getInstance("DES");

203 algBase = Cipher.Algorithm.getAlgorithmBase(cipher);

204 assertEquals("DES", algBase);

3 import cPickle

4 from Crypto.Util.randpool import RandomPool

5 from Crypto.Cipher import Blowfish

6 from Crypto.Hash import SHA

7

107 try:

108 seed = unpickler.load()

109 key = Blowfish.new(seed)

110 finally:

111 f.close()

117 self._setup_dir(self.keydir)

118 seed = self._generate_seed(8192)

119 key = Blowfish.new(seed)

120 file_name = self.keydir + self.hostname + '.key'

121 f = file(file_name, "w")

5 import java.security.GeneralSecurityException;

6

7 import javax.crypto.Cipher;

8 import javax.crypto.spec.SecretKeySpec;

9

15

16 /**

17 * Encrypts data using the blowfish cipher.

18 * @author Nathan Sweet <misc@n4te.com>

19 */

20 public class BlowfishCompressor extends Compressor {

21 private SecretKeySpec keySpec;

22

29 import random

30 from Crypto.Hash import SHA

31 from Crypto.Cipher import Blowfish

32

33 __all__ = ['MemoryStorage', 'DbmStorage', 'DecryptError']

49

50

51 class BlowfishCipher:

52 def __init__(self, key):

53 self._cipher = Blowfish.new(key)

89 @type identifier: string"""

90 self.account = account

91 self.cipher = BlowfishCipher(SHA.new(password).digest())

92 self.storage_id = identifier

93

16

17 import binascii

18 from Crypto.Cipher import Blowfish

19 from django.conf import settings

20

21 enc_obj= enc_obj= Blowfish.new(settings.SECRET_KEY)

22

23 def decrypt_attrib(attrib):

19

20 import javax.crypto.BadPaddingException;

21 import javax.crypto.Cipher;

22 import javax.crypto.IllegalBlockSizeException;

23 import javax.crypto.NoSuchPaddingException;

49 IllegalBlockSizeException

50 {

51 SecretKeySpec key = new SecretKeySpec(internalKey, "Blowfish");

52

53 BigInteger n = new BigInteger((String)secret, 16);

68 }

69

70 Cipher cipher = Cipher.getInstance("Blowfish");

71 cipher.init(Cipher.DECRYPT_MODE, key);

72 byte[] decode = cipher.doFinal(encoding);

34

35 try:

36 from Crypto.Cipher import Blowfish

37 except ImportError:

38 Blowfish = None

55

56 def encrypt_value(value, secret):

57 return Blowfish.new(secret, Blowfish.MODE_CFB) \

58 .encrypt(value).encode('string_escape')

59

60 def decrypt_value(value, secret):

61 return Blowfish.new(secret, Blowfish.MODE_CFB) \

62 .decrypt(value.decode('string_escape'))

63

19

20 try:

21 from Crypto.Cipher import Blowfish

22 except ImportError, err:

23 Blowfish = None

59 # ----------------------------------------------------------------------

60

61 def encrypt_blowfish(cipher, string):

62 string = append_padding(BLOCK_SIZE, string)

63 return base64.b64encode(cipher.encrypt(string))

64

65 def decrypt_blowfish(cipher, encoded_string):

66 dec_string = cipher.decrypt(base64.b64decode(encoded_string))

67 return remove_padding(BLOCK_SIZE, dec_string)

11

12 import javax.crypto.BadPaddingException;

13 import javax.crypto.Cipher;

14 import javax.crypto.IllegalBlockSizeException;

15 import javax.crypto.SealedObject;

122 testSealedObjectSerializableCipher001();

123 try {

124 key = Util.getInstanceKey("Blowfish");

125 assertTrue(msgNotInstance + "ColorSpace",

126 so.getObject(key) instanceof ColorSpace);

345 testSealedObjectSerializableCipher001();

346 try {

347 key = Util.getInstanceKey("Blowfish");

348 assertTrue(msgNotInstance + "ColorSpace", so.getObject(key,

349 provider) instanceof ColorSpace);

19 import base64

20 from random import randrange

21 from Crypto.Cipher import Blowfish

22 from django.conf import settings

23

26 if not key:

27 key = getattr(settings, 'SECRET_KEY')

28 self.__cipher = Blowfish.new(key)

29 def encrypt(self, text):

30 ciphertext = self.__cipher.encrypt(self.__pad_file(text))

38 cleartext = self.__depad_file(self.__cipher.decrypt(ciphertext))

39 return cleartext

40 # Blowfish cipher needs 8 byte blocks to work with

41 def __pad_file(self, text):

42 pad_bytes = 8 - (len(text) % 8)

25 import cryptix.openpgp.algorithm.PGPStringToKey;

26 import java.security.MessageDigest;

27 import javax.crypto.Cipher;

28

29 /**

269

270 ciph = null;

271 // beginTest(" 4: Blowfish /CFB");

272 try {

273 ciph = factory.getCipherAlgorithm(4, "CFB");

341

342 ciph = null;

343 // beginTest(" 4: Blowfish /OpenpgpCFB");

344 try {

345 ciph = factory.getCipherAlgorithm(4, "OpenpgpCFB");

5

6 from satchmo.configuration import config_value

7 from Crypto.Cipher import Blowfish

8 from datetime import datetime

9 try:

65 # Must remember to save it after calling!

66 secret_key = settings.SECRET_KEY

67 encryption_object = Blowfish.new(secret_key)

68 # block cipher length must be a multiple of 8

69 padding = ''

92 def _decryptCC(self):

93 secret_key = settings.SECRET_KEY

94 encryption_object = Blowfish.new(secret_key)

95 # strip padding from decrypted credit card number

96 ccnum = encryption_object.decrypt(base64.b64decode(self.encryptedCC)).rstrip('X')

9 */

10

11 import javax.crypto.Cipher;

12 import javax.crypto.spec.SecretKeySpec;

13 import java.util.Arrays;

14

15 public class BlowFishEncryptor {

16

17 public static void main(String[] args) throws Exception {

18 blowfishEncrypt("plaintextfile", "ciphertextfile");

19 }

20

1 import CakeGlobals

2 from Crypto.Cipher import Blowfish

3

4 class CakeCrypt:

5 def __init__(self):

6 alg = CakeGlobals.CAKE_MCRYPT_ALG.upper();

7 if CakeGlobals.CAKE_MCRYPT_ALG.upper() != 'BLOWFISH':

8 raise Exception('Only Blowfish algoritm supported')

10 raise Exception('Only ECB crypt mode supported')

11

12 Blowfish.key_size = len(CakeGlobals.CAKE_INTERFACE_KEY)

13 self.block_size = Blowfish.block_size

15

16 def _get_cryptor(self):

17 return Blowfish.new(CakeGlobals.CAKE_INTERFACE_KEY, eval('Blowfish.MODE_' + CakeGlobals.CAKE_MCRYPT_MODE.upper()), self._iv)

18

19 def CakeEncryptHex(self, data):

4

5 import javax.crypto.BadPaddingException;

6 import javax.crypto.Cipher;

7 import javax.crypto.IllegalBlockSizeException;

8 import javax.crypto.NoSuchPaddingException;

20

21 public static final String KEY = "jaas is the way";

22 public static final String ALGO = "Blowfish";

23

24 public String encode(String secret) {

28 try {

29 byte[] kbytes = "jaas is the way".getBytes(StandardCharsets.UTF_8);

30 SecretKeySpec key = new SecretKeySpec(kbytes, "Blowfish");

31

32 Cipher cipher = Cipher.getInstance("Blowfish");

2

3 /**

4 * Blowfish.java version 1.00.00

5 *

6 * Code Written by k2r (k2r.contact@gmail.com)

32 import java.security.InvalidKeyException;

33

34 import javax.crypto.Cipher;

35 import javax.crypto.spec.SecretKeySpec;

36

37 import net.rizon.acid.core.Logger;

38

39 public class Blowfish

40 {

41 private static final Logger log = Logger.getLogger(Blowfish.class.getName());

1 #!/usr/bin/env python

2

3 from Crypto.Cipher import Blowfish

4 from Crypto.Hash import SHA

5 from Crypto import Random

24 iv = Random.get_random_bytes(Blowfish.block_size)

25 bf = Blowfish.new(SHA.new(password).hexdigest(), Blowfish.MODE_CBC, iv)

26

27 filesize = os.path.getsize(inf)

55 iv = infile.read(Blowfish.block_size)

56 bf = Blowfish.new(SHA.new(password).hexdigest(), Blowfish.MODE_CBC, iv)

57 testdecrypt = bf.decrypt(infile.read(len(_MAGIC)))

58 if testdecrypt != _MAGIC:

7 from pdb import set_trace as trace

8

9 from Crypto.Cipher import Blowfish as bf

10

11 import ezPyCrypto as ez

37 import java.security.spec.InvalidKeySpecException;

38

39 import javax.crypto.Cipher;

40 import javax.crypto.CipherSpi;

45

46 /**

47 * This class entends the javax.crypto.CipherSpi class with a concrete

48 * implementation of the methods for wrapping and unwrapping

49 * keys.

52 *

53 *

54 * @see javax.crypto.CipherSpi

55 * @see BlowfishCipher

25 import java.security.NoSuchAlgorithmException;

26

27 import javax.crypto.Cipher;

28 import javax.crypto.CipherInputStream;

29 import javax.crypto.CipherOutputStream;

30 import javax.crypto.KeyGenerator;

31 import javax.crypto.spec.SecretKeySpec;

53 /**

54 * Creates a new <code>CipherStorageProvider</code> for the given back-end

55 * using the Blowfish cipher algorithm.

56 *

57 * @param backend

59 */

60 public CipherStorageProvider(StorageProvider backend) {

61 this(backend, "Blowfish");

62 }

63

19 import sys, os, re, tempfile, getpass, sha

20 import time

21 from Crypto.Cipher import Blowfish

22 import subprocess

23

37 iv = sha.new(str(time.time())).hexdigest()[:8]

38

39 enc = Blowfish.new(key, Blowfish.MODE_CBC, iv)

40 data += "X" * padding

41 data = enc.encrypt(data)

50 data = data[9:].decode('base64')

51

52 enc = Blowfish.new(key, Blowfish.MODE_CBC, iv)

53 data = enc.decrypt(data)

54

12 {

13 javax.crypto.spec.SecretKeySpec sksSpec =

14 new javax.crypto.spec.SecretKeySpec(key.getBytes(), "Blowfish");

15 javax.crypto.Cipher cipher =

16 javax.crypto.Cipher.getInstance("Blowfish");

17 cipher.init(javax.crypto.Cipher.ENCRYPT_MODE, sksSpec);

29 {

30 javax.crypto.spec.SecretKeySpec sksSpec =

31 new javax.crypto.spec.SecretKeySpec(key.getBytes(), "Blowfish");

32 javax.crypto.Cipher cipher =

33 javax.crypto.Cipher.getInstance("Blowfish");

34 cipher.init(javax.crypto.Cipher.DECRYPT_MODE, sksSpec);

28

29 /**

30 * Test cases for the {@link org.apache.shiro.crypto.cipher.BlowfishCipherService} class.

31 *

32 * @since 1.0

41 @Test

42 public void testBlockOperations() {

43 BlowfishCipherService blowfish = new BlowfishCipherService();

44

45 byte[] key = blowfish.generateNewKey().getEncoded();

61 public void testStreamingOperations() {

62

63 BlowfishCipherService cipher = new BlowfishCipherService();

64 byte[] key = cipher.generateNewKey().getEncoded();

65

2 +++ pycrypto/setup.py

3 @@ -94,13 +94,6 @@

4 Extension("Crypto.Cipher.DES3",

5 include_dirs=['src/'],

6 sources=["src/DES3.c"]),

7 - Extension("Crypto.Cipher.IDEA",

8 - include_dirs=['src/'],

9 - sources=["src/IDEA.c"],

10 - libraries=HTONS_LIBS),

11 - Extension("Crypto.Cipher.RC5",

12 - include_dirs=['src/'],

13 - sources=["src/RC5.c"]),

20

21 #

22 # ssh.cipher.blowfish_cbc

23 #

24 # Implements the Blowfish cipher in CBC mode.

26

27 from coro.ssh.cipher import SSH_Cipher_Method

28 from Crypto.Cipher import Blowfish

29

30 class Blowfish_CBC(SSH_Cipher_Method):

31

32 name = 'blowfish-cbc'

33 block_size = 8

34 key_size = 16

45 self.key = key

46 self.IV = IV

47 self.cipher = Blowfish.new(key, Blowfish.MODE_CBC, IV)

48

3 * Please refer to the LICENSE.txt for licensing details.

4 */

5 package ch.ethz.ssh2.crypto.cipher;

6

7 import java.util.ArrayList;

38 {

39 /* Higher Priority First */

40 ciphers.add(new CipherEntry("aes128-ctr", 16, 16, "ch.ethz.ssh2.crypto.cipher.AES"));

41 ciphers.add(new CipherEntry("aes192-ctr", 16, 24, "ch.ethz.ssh2.crypto.cipher.AES"));

42 ciphers.add(new CipherEntry("aes256-ctr", 16, 32, "ch.ethz.ssh2.crypto.cipher.AES"));

43 ciphers.add(new CipherEntry("blowfish-ctr", 8, 16, "ch.ethz.ssh2.crypto.cipher.BlowFish"));

44

45 ciphers.add(new CipherEntry("aes128-cbc", 16, 16, "ch.ethz.ssh2.crypto.cipher.AES"));

47 ciphers.add(new CipherEntry("aes256-cbc", 16, 32, "ch.ethz.ssh2.crypto.cipher.AES"));

48 ciphers.add(new CipherEntry("blowfish-cbc", 8, 16, "ch.ethz.ssh2.crypto.cipher.BlowFish"));

49

50 ciphers.add(new CipherEntry("3des-ctr", 8, 24, "ch.ethz.ssh2.crypto.cipher.DESede"));

21 import java.security.spec.X509EncodedKeySpec;

22 import java.util.Formatter;

23 import javax.crypto.Cipher;

24 import javax.crypto.CipherInputStream;

25 import javax.crypto.CipherOutputStream;

26 import javax.crypto.KeyGenerator;

27 import javax.crypto.SecretKey;

34 public class PKE {

35

36 static final String symmetricAlgorithm = "Blowfish";

37 static final String asymmetricAlgorithm = "RSA";

38 static final String pkInstance = "RSA/ECB/PKCS1Padding";

119 System.out.println("Secret Bytes Length: " + secretBytes.length);

120 System.out.println("Secret Key Bytes: " + byteArray2Hex(secretBytes));

121 Cipher BlowfishCipher = Cipher.getInstance(symmetricAlgorithm);

122 BlowfishCipher.init(Cipher.ENCRYPT_MODE, symmetricKey);

2 from twisted.web import static, server, resource

3 from xml.sax.saxutils import escape

4 from Crypto.Cipher import Blowfish

5

6 from fiveserver import log

36 self.config = config

37 self.webDir = webDir

38 self.cipher = Blowfish.new(binascii.a2b_hex(self.config.cipherKey))

39

40 def render_GET(self, request):

17 package taska.commons.security;

18

19 import javax.crypto.Cipher;

20 import javax.crypto.spec.SecretKeySpec;

21

26 public class CipherUtil {

27

28 public static byte[] encryptBlowfish(String key, String text) {

29 SecretKeySpec k = new SecretKeySpec(key.getBytes(), "Blowfish");

30 try {

31 Cipher cipher = Cipher.getInstance("Blowfish");

32 cipher.init(Cipher.ENCRYPT_MODE, k);

33 return cipher.doFinal(text.getBytes());

37 }

38

39 public static String decryptBlowfish(String key, byte[] byteArray) {

40 SecretKeySpec k = new SecretKeySpec(key.getBytes(), "Blowfish");

8

9 from functools import partial

10 from Crypto.Cipher import AES, Blowfish

11

12 try:

30

31 aes = partial(_cipher, AES)

32 blowfish = partial(_cipher, Blowfish)

33

34

68 #aes and blowfish ciphers

69 self._aes = aes(passwd)

70 self._blowfish = blowfish(passwd)

71

72 mode = 'r' if os.path.exists(db) else 'w+'

9 '''

10

11 -from Crypto.Cipher import Blowfish

12 +import sys

13 +import os

14 +from Crypto.Cipher import Blowfish, AES

15 from elixir.statements import Statement

16 from sqlalchemy.orm import MapperExtension, EXT_CONTINUE, EXT_STOP

25 +# backward compatibility needed to migrate data. Use AES instead!

26 def encrypt_value(value, secret):

27 return Blowfish.new(secret, Blowfish.MODE_CFB) \

28 .encrypt(value).encode('string_escape')

29 @@ -58,14 +62,36 @@

1 # -*- encoding: utf-8 -*-

2 import sqlite3

3 from Crypto.Cipher import Blowfish # pkg install "python-crypto"

4 from binascii import hexlify, unhexlify

5

41 if True:

42 try:

43 crypt = Blowfish.new(opts.key, Blowfish.MODE_ECB) # default = CBC

44 ciphertext = unhexlify(mail_text)

45 plaintext = crypt.decrypt(ciphertext)

46 print unicode(plaintext, "utf-8")

47 except Exception, e:

48 print "Blowfish OOPS", str(e)

49 else:

50 print mail_text

22 import java.security.spec.RSAKeyGenParameterSpec;

23

24 import javax.crypto.Cipher;

25 import javax.crypto.KeyGenerator;

26 import javax.crypto.SecretKey;

31

32 /**

33 * Key generator. It generates keys or keyPairs for Blowfish and RSA

34 *

35 * @author -Nemesiss-

62 log.info("Initializing Key Generator...");

63

64 blowfishKeyGen = KeyGenerator.getInstance("Blowfish");

65

66 KeyPairGenerator rsaKeyPairGenerator = KeyPairGenerator.getInstance("RSA");

36 "ch.ethz.ssh2.crypto.cipher.AES"));

37 ciphers.addElement(new CipherEntry("aes128-ctr", 16, 16,

38 "ch.ethz.ssh2.crypto.cipher.AES"));

39 ciphers.addElement(new CipherEntry("blowfish-ctr", 8, 16,

40 "ch.ethz.ssh2.crypto.cipher.BlowFish"));

41

42 ciphers.addElement(new CipherEntry("aes256-cbc", 16, 32,

43 "ch.ethz.ssh2.crypto.cipher.AES"));

44 ciphers.addElement(new CipherEntry("aes192-cbc", 16, 24,

45 "ch.ethz.ssh2.crypto.cipher.AES"));

48 ciphers.addElement(new CipherEntry("blowfish-cbc", 8, 16,

49 "ch.ethz.ssh2.crypto.cipher.BlowFish"));

50

51 ciphers.addElement(new CipherEntry("3des-ctr", 8, 24,

4 """

5

6 from Crypto.Cipher import Blowfish

7 from datetime import datetime

8 from django.conf import settings

60 # Must remember to save it after calling!

61 secret_key = settings.SECRET_KEY

62 encryption_object = Blowfish.new(secret_key)

63 # block cipher length must be a multiple of 8

64 padding = ''

87 def _decryptCC(self):

88 secret_key = settings.SECRET_KEY

89 encryption_object = Blowfish.new(secret_key)

90 # strip padding from decrypted credit card number

91 ccnum = encryption_object.decrypt(base64.b64decode(self.encryptedCC)).rstrip('X')

4 """

5

6 from Crypto.Cipher import Blowfish

7 from datetime import datetime

8 from decimal import Decimal

111 """Decrypt code encrypted by _encrypt_code"""

112 secret_key = settings.SECRET_KEY

113 encryption_object = Blowfish.new(secret_key)

114 # strip padding from decrypted credit card number

115 return encryption_object.decrypt(base64.b64decode(code)).rstrip('X')

118 """Quick encrypter for CC codes or code fragments"""

119 secret_key = settings.SECRET_KEY

120 encryption_object = Blowfish.new(secret_key)

121 # block cipher length must be a multiple of 8

122 padding = ''

5

6 import sys

7 from Crypto.Cipher import Blowfish

8 from argh import ArghParser, command

9 from getpass import getpass

17 except KeyboardInterrupt:

18 sys.exit()

19 encrypter = Blowfish.new(password)

20

21 name = _ensure_multiple8(name)

5 import javax.crypto.spec.*;

6 import java.security.Key;

7 import javax.crypto.Cipher;

8 import javax.crypto.spec.SecretKeySpec;

9

23 password = pass.toString();

24 try {

25 clef = new SecretKeySpec(password.getBytes("UTF-8"), "Blowfish");

26 } catch (Exception e) {

27 e.printStackTrace();

31 public byte[] crypter(final byte[] acrypt) {

32 try {

33 Cipher cipher = Cipher.getInstance("Blowfish");

34 cipher.init(Cipher.ENCRYPT_MODE, clef);

35 return cipher.doFinal(acrypt);

5 'dojox/encoding/base64',

6 'dojox/encoding/crypto/_base',

7 'dojox/encoding/crypto/Blowfish'

8 ], function(declare, xhr, json, base64, crypto, Blowfish) {

94 query = json.stringify(query);

95

96 return Blowfish.encrypt(query, this.apiSecret, {

97 mode: crypto.cipherModes.ECB,

31 import java.util.Locale;

32

33 import javax.crypto.Cipher;

34

35 public class Turkish {

43 System.out.println(Cipher.getInstance("RSA/ECB/PKCS1PADDING"));

44 System.out.println(Cipher.getInstance("rsa/ecb/pkcs1padding"));

45 System.out.println(Cipher.getInstance("Blowfish"));

46 System.out.println(Cipher.getInstance("blowfish"));

47 System.out.println(Cipher.getInstance("BLOWFISH"));

48

49 System.out.println("OK");

1

2 from Crypto.Cipher import Blowfish

3 from random import randrange

4

5 class SerializerBlowfish(object):

6 # def __init__(self):

7 # pass

8

9 def dumps(self,obj,encrkey):

10 bf=Blowfish.new(encrkey)

11 return bf.encrypt(self.__pad_file(str(obj)))

12

13 def loads(self,s,encrkey):

14 bf=Blowfish.new(encrkey)

15 return self.__depad_file(bf.decrypt(s))

16

1 package jp.go.ipa.ipf.birtviewer.util;

2

3 import javax.crypto.Cipher;

4 import javax.crypto.spec.SecretKeySpec;

5

29 byte[] key = CIPHER_KEY.getBytes(); // 暗号化キー

30

31 SecretKeySpec sksSpec = new SecretKeySpec(key, "Blowfish");

32 Cipher cipher = Cipher.getInstance("Blowfish");

57 byte[] key = CIPHER_KEY.getBytes(); // 複号化キー

58

59 SecretKeySpec sksSpec = new SecretKeySpec(key, "Blowfish");

60 Cipher cipher = Cipher.getInstance("Blowfish");

5

6 import base64

7 from Crypto.Cipher import Blowfish

8 from django.db import models

9 from django.conf import settings

57 # Must remember to save it after calling!

58 secret_key = settings.SECRET_KEY

59 encryption_object = Blowfish.new(secret_key)

60 # block cipher length must be a multiple of 8

61 padding = ''

67 def _decryptCC(self):

68 secret_key = settings.SECRET_KEY

69 encryption_object = Blowfish.new(secret_key)

70 # strip padding from decrypted credit card number

71 ccnum = encryption_object.decrypt(base64.b64decode(self.encryptedCC)).rstrip('X')

39 public KeyGen()

40 {

41 super("Blowfish", 128, new CipherKeyGenerator());

42 }

43 }

57 public Mappings()

58 {

59 put("Cipher.BLOWFISH", "org.bouncycastle.jce.provider.symmetric.Blowfish$ECB");

60 // BEGIN android-removed

61 // put("Cipher.1.3.6.1.4.1.3029.1.2", "org.bouncycastle.jce.provider.symmetric.Blowfish$CBC");

62 // END android-removed

63 put("KeyGenerator.BLOWFISH", "org.bouncycastle.jce.provider.symmetric.Blowfish$KeyGen");

64 put("Alg.Alias.KeyGenerator.1.3.6.1.4.1.3029.1.2", "BLOWFISH");

65 put("AlgorithmParameters.BLOWFISH", "org.bouncycastle.jce.provider.symmetric.Blowfish$AlgParams");

66 put("Alg.Alias.AlgorithmParameters.1.3.6.1.4.1.3029.1.2", "BLOWFISH");

35 *

36 */

37 public class BlowFishCrypt {

38

39 private SecretKeySpec secretKeySpec = null;

51 * @param key An encoded secret key

52 */

53 public BlowFishCrypt(byte[] key) {

54 try {

55 secretKeySpec = new SecretKeySpec(key, "Blowfish");

142 public static boolean testKey(byte[] key) {

143 String testString = "1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstufwxyz";

144 BlowFishCrypt c = new BlowFishCrypt(key);

145 byte[] encryptedBytes = c.encrypt(testString);

146 String encryptedMessage = new String(encryptedBytes);

9

10 public class PasswordUtils {

11 private static final String ALGORITHM = "Blowfish";

12

13 public static byte[] encrypt(String key, String text) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {

14 javax.crypto.spec.SecretKeySpec sksSpec = new javax.crypto.spec.SecretKeySpec(key.getBytes(), ALGORITHM);

15 javax.crypto.Cipher cipher = javax.crypto.Cipher.getInstance(ALGORITHM);

16 cipher.init(javax.crypto.Cipher.ENCRYPT_MODE, sksSpec);

21 public static String decrypt(String key, byte[] encrypted) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {

22 javax.crypto.spec.SecretKeySpec sksSpec = new javax.crypto.spec.SecretKeySpec(key.getBytes(), ALGORITHM);

23 javax.crypto.Cipher cipher = javax.crypto.Cipher.getInstance(ALGORITHM);

24 cipher.init(javax.crypto.Cipher.DECRYPT_MODE, sksSpec);

9 import java.util.Date;

10

11 import javax.crypto.Cipher;

12 import javax.crypto.KeyGenerator;

13 import javax.crypto.SecretKey;

15 import com.agmc.crypto.provider.MyToolkit;

16

17 public class PruebaBlowfish extends PruebaJCE {

18

19 public static void main(String[] args) {

20 byte[] cifrado1 = null;

21 byte[] cifrado2 = null;

22 byte[] mensaje = "Hola esto es una prueba de mi algoritmo Blowfish... parece ser que es muy lento".getBytes();

23

24 try {

1 package gnu.crypto.cipher;

2

3 // ----------------------------------------------------------------------------

92 if (name.equalsIgnoreCase(ANUBIS_CIPHER)) {

93 result = new Anubis();

94 } else if (name.equalsIgnoreCase(BLOWFISH_CIPHER)) {

95 result = new Blowfish();

134 HashSet hs = new HashSet();

135 hs.add(ANUBIS_CIPHER);

136 hs.add(BLOWFISH_CIPHER);

137 hs.add(DES_CIPHER);

138 hs.add(KHAZAD_CIPHER);

5 import os, sys

6 from random import randrange

7 from Crypto.Cipher import Blowfish

8

9 # This script reads in the apps-whitelist.txt file and generates

60

61

62 # Blowfish cipher needs 8 byte blocks to work with

63 def __pad_file( file_buffer):

64 pad_bytes = 8 - (len(file_buffer) % 8)

96 key="Copyright 2009 Palm Inc."

97 filename = "/usr/lib/lib_id.so"

98 __cipher = Blowfish.new(key,Blowfish.MODE_CBC)

99 result = __cipher.encrypt(__pad_file(kApps))

100

4 #import blowfish

5 from Crypto.Cipher import Blowfish

6

7 def create(parent):

124 def __init__(self, parent):

125 self._init_ctrls(parent)

126 self.crypt = Blowfish.new('SoftArchi', Blowfish.MODE_ECB)

127

128 config = wx.ConfigBase_Get()

25 import java.security.InvalidKeyException;

26 import java.security.NoSuchAlgorithmException;

27 import javax.crypto.Cipher;

28 import javax.crypto.NoSuchPaddingException;

29 import javax.crypto.spec.IvParameterSpec;

40 * @version $Revision: 1.21 $

41 */

42 public class BlowfishCbc

43 extends SshCipher {

44 private static Log log = LogFactory.getLog(BlowfishCbc.class);

45

46 /** */

47 protected static String algorithmName = "blowfish-cbc";

48 Cipher cipher;

49