Problemas com getByte()

class StringNaoEhArrayDeBytes {
    public static void main(String[] args) throws Exception {
        byte[] bytes = new byte[256];
        // Primeiramente estamos preenchendo o array "bytes" com 
        // os valores de 0 até 255
        for (int i = 0; i < bytes.length; ++i) {
            bytes[i] = (byte) i;
        }
        // Agora vamos converter ingenuamente esse array de bytes para uma string. 
        // Vamos usar o "encoding" Windows-1252 porque é o que dá menos problemas
        String s = new String (bytes, "Windows-1252");
        // Vamos desconverter a string para um array de bytes.
        byte[] bytes2 = s.getBytes ("Windows-1252");
        // Agora vamos conferir para ver quais dos bytes foram convertidos erroneamente.
        for (int i = 0; i < bytes.length; i++) {
            byte b = (byte) i;
            if (bytes2[i] != b) {
                System.out.printf ("O byte 0x%02X foi perdido e transformado em 0x%02X (%c) %n",
                    (byte) i, 
                    bytes2[i],
                    (char) bytes2[i]);
            }
        }
    }
}

O byte 0x81 foi perdido e transformado em 0x3F (?)
O byte 0x8D foi perdido e transformado em 0x3F (?)
O byte 0x8F foi perdido e transformado em 0x3F (?)
O byte 0x90 foi perdido e transformado em 0x3F (?)
O byte 0x9D foi perdido e transformado em 0x3F (?)

String s = new String (texto); // onde texto é um array de bytes, não criptografados

String s = new String (texto, "ISO-8859-1"); // onde texto é um array de bytes.

import org.bouncycastle.crypto.*;
import org.bouncycastle.crypto.engines.*;
import org.bouncycastle.crypto.modes.*;
import org.bouncycastle.crypto.params.*;

// A simple example that uses the Bouncy Castle
// lightweight cryptography API to perform DES
// encryption of arbitrary data.

public class Encryptor {
    
    private BufferedBlockCipher cipher;
    private KeyParameter key;
    
    // Initialize the cryptographic engine.
    // The key array should be at least 8 bytes long.
    
    public Encryptor( byte[] key ){
        /*
        cipher = new PaddedBlockCipher(
                 new CBCBlockCipher(
                 new DESEngine() ) );
         */
        
        cipher = new PaddedBlockCipher(
                new CBCBlockCipher(
                new BlowfishEngine() ) );
        
        this.key = new KeyParameter( key );
    }
    
    // Initialize the cryptographic engine.
    // The string should be at least 8 chars long.
    
    public Encryptor( String key ){
        this( key.getBytes() );
    }
    
    // Private routine that does the gritty work.
    
    private byte[] callCipher( byte[] data )
    throws CryptoException {
        int    size =
                cipher.getOutputSize( data.length );
        byte[] result = new byte[ size ];
        int    olen = cipher.processBytes( data, 0,
                data.length, result, 0 );
        olen += cipher.doFinal( result, olen );
        
        if( olen < size ){
            byte[] tmp = new byte[ olen ];
            System.arraycopy(
                    result, 0, tmp, 0, olen );
            result = tmp;
        }
        
        return result;
    }
    
    // Encrypt arbitrary byte array, returning the
    // encrypted data in a different byte array.
    
    public synchronized byte[] encrypt( byte[] data )
    throws CryptoException {
        if( data == null || data.length == 0 ){
            return new byte[0];
        }
        
        cipher.init( true, key );
        return callCipher( data );
    }
    
    // Encrypts a string.
    
    public byte[] encryptString( String data )
    throws CryptoException {
        if( data == null || data.length() == 0 ){
            return new byte[0];
        }
        
        return encrypt( data.getBytes() );
    }
    
    // Decrypts arbitrary data.
    
    public synchronized byte[] decrypt( byte[] data )
    throws CryptoException {
        if( data == null || data.length == 0 ){
            return new byte[0];
        }
        
        cipher.init( false, key );
        return callCipher( data );
    }
    
    // Decrypts a string that was previously encoded
    // using encryptString.
    
    public String decryptString( byte[] data )
    throws CryptoException {
        if( data == null || data.length == 0 ){
            return "";
        }
        
        return new String( decrypt( data ) );
    }
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.Reader;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import org.bouncycastle.crypto.CryptoException;

/**
 * @author usuario
 */
public class Midlet extends MIDlet {
    public void startApp() {
        
 
        
        String key = "asdf";
        
        Encryptor obj = new Encryptor(key); 
        
        String txt = "cuiabá";
        
        byte[] res = null;
            try {
                res = obj.encryptString(txt);
            } catch (CryptoException ex) {
                ex.printStackTrace();
            }
        
        System.out.println("Crip: "+res);
        
    
       String str = null; 
        try {
            str = obj.decryptString(res);
        } catch (CryptoException ex) {
            ex.printStackTrace();
        }
         
        
        System.out.println("Descrip: "+str);
        
        
     
        
        
    }

  
    
    
    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}