Characters jumbled pls help

[Archies Gomes]

Hi
I am facing a very critical problem.....i am into cryptography and using DES algorithm to encrypt and decrypt a plain text.....
The main problem lies when i encrypt a particular plain text we get a set of weird characters being generated now when i try to send these characters through a socket then at the other end the reading is not interpreted properly....by this i mean that all characters in the ascii range 148-160 have a representation of a '?')(try printing on the console) and when any character(generated after encrypting) of this range is read at the other end it is read as a character with ascii value 63 which corresponds to real '?'.Why does this happen....

[Arnaud Burlet]

I'm not sure why it happens, depends on how you send and receive the encrypted stuff, sorry.

But I'm sure you should not encrypt/send/decrypt char[], you should encrypt/send/decrypt byte[].

byte[] encrypted = encrypt(yourString.getBytes("UTF-8"));
send(encrypted);
byte[] toDecrypt;
receive(toDecrypt)
new String(decrypt(toDecrypt), "UTF-8");

[David O'Meara]

"archies",
It appears that you had a valid display name and have changed it so it is no longer valid. Please change it back immediately, since accounts with invalid display names get deleted, often without warning.

Thanks,
David.

[James Sabre]

I infer that you are encrypting some bytes and then converting them to a String using something like

byte[] encryptedBytes = cipher.doFinal(planeTextBytes);
String encrypted = new String(encryptedBytes);

This is almost certainly doomed to failure because not all byte combinations convert (reversibly) to a String. If you realy do need to send ASCII character then your best bet is to Base64 or Hex encode the encrypedBytes.

I try not to convert encrypted bytes or hash bytes to a String. The only time I have needed to is when I had to put hash bytes into a DB table where I was not allowed (customer forbade it) to to change the table structure in any way.

The following is my standard demonstration of DES encryption and shows an example of the use of Base64 to encode encrypted data.

 import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.*;
import sun.misc.*;
 
public class DESEncryptDataString
{
    static public class EncryptionException extends Exception
    {
        private EncryptionException(String text, Exception chain)
        {
            super(text, chain);
        }
    }
    
    public DESEncryptDataString(byte[] keyBytes, byte[] ivBytes, String characterEncoding) throws EncryptionException
    {
        assert (keyBytes != null) && (keyBytes.length == 8);
        assert (ivBytes != null) && (ivBytes.length == 8);
        assert (characterEncoding != null);
        
        try
        {
            SecretKey key1 = new SecretKeySpec(keyBytes, "DES");
            
            // To demonstrate that the least significant bit is the parity bit and can be ignored.
            keyBytes[0] ^=0x01;
            SecretKey key2 = new SecretKeySpec(keyBytes, "DES");
            IvParameterSpec iv = new IvParameterSpec(ivBytes);
            this.characterEncoding = characterEncoding;
            this.encryptCipher = Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
            this.encryptCipher.init(javax.crypto.Cipher.ENCRYPT_MODE, key1, iv);
            this.decryptCipher = Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
            this.decryptCipher.init(javax.crypto.Cipher.DECRYPT_MODE, key2, iv);
        }
        catch (Exception e)
        {
            throw new EncryptionException("Problem constucting " + this.getClass().getName(), e);
        }
    }
    
    synchronized public String encrypt(String dataString) throws EncryptionException
    {
        assert dataString != null;
        
        try
        {
            byte[] dataStringBytes = dataString.getBytes(characterEncoding);
            byte[] encryptedDataStringBytes = this.encryptCipher.doFinal(dataStringBytes);
            String encodedEncryptedDataString = this.base64Encoder.encode(encryptedDataStringBytes);
            return encodedEncryptedDataString;
        }
        catch (Exception e)
        {
            throw new EncryptionException("Problem encrypting string", e);
        }
    }
    
    synchronized public String decrypt(String encodedEncryptedDataString) throws EncryptionException
    {
        try
        {
            byte[] encryptedDataStringBytes = this.base64Decoder.decodeBuffer(encodedEncryptedDataString);
            byte[] dataStringBytes = this.decryptCipher.doFinal(encryptedDataStringBytes);
            String dataString = new String(dataStringBytes, characterEncoding);
            return dataString;
        }
        catch (Exception e)
        {
            throw new EncryptionException("Problem decrypting string", e);
        }
    }
    
    public static void main(String[] args)
    {
        try
        {
            // Make sure SUN are a valid provider
            Security.addProvider(new com.sun.crypto.provider.SunJCE());
            
            // The DES Key - any 8 bytes will do though beware of weak keys.
            // This could be read from a file.
            final byte[] keyBytes = "01234567".getBytes("ASCII");
            
            // IV For CBC mode
            // Again, could be read from a file.
            final byte[] IVBytes = "ABCDEFGH".getBytes("ASCII");
            
            // Data string encrypt agent that assumes the data string is only ASCII characters
            DESEncryptDataString dataStringEncryptAgent = new DESEncryptDataString(keyBytes, IVBytes, "UTF-8");
            
            // Get the data string to encrypt from the command line
            String dataString = (args.length == 0)? "The quick brown fox jumps over the lazy dog." : args[0];
            System.out.println("Data string ....................[" + dataString + "]");
            
            String encodedEncryptedDataString = dataStringEncryptAgent.encrypt(dataString);
            System.out.println("Encoded encrypted data string ..[" + encodedEncryptedDataString + "]");
            
            String recoveredDataString = dataStringEncryptAgent.decrypt(encodedEncryptedDataString);
            System.out.println("Recovered data string ..........[" + recoveredDataString + "]");
        }
        catch (Exception e)
        {
            e.printStackTrace(System.out);
        }
    }
    
    private String characterEncoding;
    private Cipher encryptCipher;
    private Cipher decryptCipher;
    private BASE64Encoder base64Encoder = new BASE64Encoder();
    private BASE64Decoder base64Decoder = new BASE64Decoder();
}
 

[Archies Gomes]

Hi All
Thanks for your response ....but someone said that i should convert the characters to byte from and then send it ...but what happens is that characters above the ascii value 127 does not gets stored in a byte(as byte ranges from -128 to 127) and thus these values are stored wrongly .So i went in for writer class which uses characters rather then having stream classes and thus faced that problem.......But i basically dont understand how are characters interpreted wrongly...You all can try sending characters within ascii range 148-160 and receive them at the other end...They are interpreted wrongly(read as character with ascii 63).

[Ernest Friedman-Hill]

Archies,

As David has already asked you (see above), please change your display name to comply with our policy. You need a real-sounding first and last name. Don't post again before making the change. Thank you.