Android 发送短信时出错

你好，我正在制作一个adroid应用程序，用于加密和解密短信。我有一个问题，当短信的大小超过80个字符的短信无法发送和应用程序。停止工作（给出错误）（少于80个字符无错误，我可以发送短信）。我首先将消息转换为字节（

UTF-8

），然后使用

getBytes（）

加密并发送

这是logcat中的错误：

06-05 12:16:42.460: E/AndroidRuntime(333): java.lang.NullPointerException
06-05 12:16:42.460: E/AndroidRuntime(333):android.os.Parcel.readException(Parcel.java:1328)
06-05 12:16:42.460: E/AndroidRuntime(333):android.os.Parcel.readException(Parcel.java:1276)
06-05 12:16:42.460: E/AndroidRuntime(333):atcom.android.internal.telephony.ISms$Stub$Proxy.sendText(ISms.java:369)
06-05 12:16:42.460: E/AndroidRuntime(333):atandroid.telephony.SmsManager.sendTextMessage(SmsManager.java:87)
06-05 12:16:42.460: E/AndroidRuntime(333):atcom.cryptosms.MainActivity.sendSMS(MainActivity.java:296)
06-05 12:16:42.460: E/AndroidRuntime(333):atcom.cryptosms.MainActivity$3.onClick(MainActivity.java:142)
06-05 12:16:42.460: E/AndroidRuntime(333):at android.view.View.performClick(View.java:2485)
06-05 12:16:42.460: E/AndroidRuntime(333):atandroid.view.View$PerformClick.run(View.java:9080)
06-05 12:16:42.460: E/AndroidRuntime(333): atandroid.os.Handler.handleCallback(Handler.java:587)
06-05 12:16:42.460: E/AndroidRuntime(333): atandroid.os.Handler.dispatchMessage(Handler.java:92)
06-05 12:16:42.460: E/AndroidRuntime(333): at android.os.Looper.loop(Looper.java:123)
06-05 12:16:42.460: E/AndroidRuntime(333): atandroid.app.ActivityThread.main(ActivityThread.java:3683)
06-05 12:16:42.460: E/AndroidRuntime(333): at java.lang.reflect.Method.invokeNative(Native Method)
06-05 12:16:42.460: E/AndroidRuntime(333):atjava.lang.reflect.Method.invoke(Method.java:507)
06-05 12:16:42.460: E/AndroidRuntime(333):atcom.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:839)
06-05 12:16:42.460: E/AndroidRuntime(333):atcom.android.internal.os.ZygoteInit.main(ZygoteInit.java:597)
06-05 12:16:42.460: E/AndroidRuntime(333): at dalvik.system.NativeStart.main(Native Method)

---

您好，请尝试使用下面的代码进行加密和解密

import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

/**
 * Usage:
 * <pre>
 * String crypto = SimpleCrypto.encrypt(masterpassword, cleartext)
 * ...
 * String cleartext = SimpleCrypto.decrypt(masterpassword, crypto)
 * </pre>
 * @author ferenc.hechler
 */
public class SimpleCrypto {


    public static void main(String args[])
    {


        try {

            String sr=encrypt("username", "The AsyncTask isn’t the only way to do background processing in Android, though. The Loader class is a much newer construct in Android (although now it’s getting a bit dated). It was released with Honeycomb(3.0) and is now included in the Support Library. The beauty of the Loader is that it handles some of the ‘gotchas’ that usually are missed when using the AsyncTask. Mainly, it handles activity configuration changes (IE when the user rotates the screen)");
            System.out.println(" &&&& " + sr);
            System.out.println("88888 "+decrypt("username", sr));


        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
        public static String encrypt(String seed, String cleartext) throws Exception {
                byte[] rawKey = getRawKey(seed.getBytes());
                byte[] result = encrypt(rawKey, cleartext.getBytes());
                return toHex(result);
        }

        public static String decrypt(String seed, String encrypted) throws Exception {
                byte[] rawKey = getRawKey(seed.getBytes());
                byte[] enc = toByte(encrypted);
                byte[] result = decrypt(rawKey, enc);
                return new String(result);
        }

        private static byte[] getRawKey(byte[] seed) throws Exception {
                KeyGenerator kgen = KeyGenerator.getInstance("AES");
                SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
                sr.setSeed(seed);
            kgen.init(128, sr); // 192 and 256 bits may not be available
            SecretKey skey = kgen.generateKey();
            byte[] raw = skey.getEncoded();
            return raw;
        }


        private static byte[] encrypt(byte[] raw, byte[] clear) throws Exception {
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
                Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
            byte[] encrypted = cipher.doFinal(clear);
                return encrypted;
        }

        private static byte[] decrypt(byte[] raw, byte[] encrypted) throws Exception {
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
                Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, skeySpec);
            byte[] decrypted = cipher.doFinal(encrypted);
                return decrypted;
        }

        public static String toHex(String txt) {
                return toHex(txt.getBytes());
        }
        public static String fromHex(String hex) {
                return new String(toByte(hex));
        }

        public static byte[] toByte(String hexString) {
                int len = hexString.length()/2;
                byte[] result = new byte[len];
                for (int i = 0; i < len; i++)
                        result[i] = Integer.valueOf(hexString.substring(2*i, 2*i+2), 16).byteValue();
                return result;
        }

        public static String toHex(byte[] buf) {
                if (buf == null)
                        return "";
                StringBuffer result = new StringBuffer(2*buf.length);
                for (int i = 0; i < buf.length; i++) {
                        appendHex(result, buf[i]);
                }
                return result.toString();
        }
        private final static String HEX = "0123456789ABCDEF";
        private static void appendHex(StringBuffer sb, byte b) {
                sb.append(HEX.charAt((b>>4)&0x0f)).append(HEX.charAt(b&0x0f));
        }

}

导入java.security.SecureRandom；
导入javax.crypto.Cipher；
导入javax.crypto.KeyGenerator；
导入javax.crypto.SecretKey；
导入javax.crypto.spec.SecretKeySpec；
/**
*用法：
* 
*String crypto=SimpleCrypto.encrypt（主密码，明文）
* ...
*String cleartext=SimpleCrypto.decrypt（主密码，加密）
* 
*@author ference.hechler
*/
公共类SimpleCrypto{
公共静态void main（字符串参数[]）
{
试一试{
String sr=encrypt（“username”，“异步任务”并不是Android中进行后台处理的唯一方法。Loader类在Android中是一个更新得多的结构（尽管现在它有点过时）。它是与Honeycom（3.0）一起发布的现在包含在支持库中。加载器的优点在于它可以处理一些在使用AsyncTask时通常会丢失的“gotchas”。主要是，它可以处理活动配置更改（即当用户旋转屏幕时）”；
System.out.println（“&&&&&&”+sr）；
System.out.println（“88888”+解密（“用户名”，sr））；
}捕获（例外e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
公共静态字符串加密（字符串种子、字符串明文）引发异常{
byte[]rawKey=getRawKey（seed.getBytes（））；
byte[]result=encrypt（rawKey，cleartext.getBytes（））；
返回到hex（结果）；
}
公共静态字符串解密（字符串种子、字符串加密）引发异常{
byte[]rawKey=getRawKey（seed.getBytes（））；
字节[]enc=toByte（加密）；
字节[]结果=解密（rawKey，enc）；
返回新字符串（结果）；
}
私有静态字节[]getRawKey（字节[]种子）引发异常{
KeyGenerator kgen=KeyGenerator.getInstance（“AES”）；
SecureRandom sr=SecureRandom.getInstance（“SHA1PRNG”）；
高级种子（种子）；
kgen.init（128，sr）；//192和256位可能不可用
SecretKey skey=kgen.generateKey（）；
字节[]原始=skey.getEncoded（）；
返回原材料；
}
私有静态字节[]加密（字节[]原始，字节[]清除）引发异常{
SecretKeySpec skeySpec=新SecretKeySpec（原始，“AES”）；
Cipher Cipher=Cipher.getInstance（“AES”）；
cipher.init（cipher.ENCRYPT_模式，skeySpec）；
字节[]加密=cipher.doFinal（清除）；
返回加密；
}
私有静态字节[]解密（字节[]原始，字节[]加密）引发异常{
SecretKeySpec skeySpec=新SecretKeySpec（原始，“AES”）；
Cipher Cipher=Cipher.getInstance（“AES”）；
cipher.init（cipher.DECRYPT_模式，skeySpec）；
字节[]解密=cipher.doFinal（加密）；
返回解密；
}
公共静态字符串toHex（字符串txt）{
返回到hex（txt.getBytes（））；
}
公共静态字符串fromHex（字符串十六进制）{
返回新字符串（toByte（hex））；
}
公共静态字节[]toByte（字符串hexString）{
int len=hexString.length（）/2；
字节[]结果=新字节[len]；
对于（int i=0；i>4）和0x0f））.append（十六进制字符（b和0x0f））；
}
}

您是否尝试用超过80个字符加密字符串？这是您在sms中传递的内容的解析错误。你有什么特别的角色吗？你是否适当地处理了它们？是的，我输入了80个字符或更多，但我也得到了相同的错误，少于80个就可以了，我可以加密和解密。不，我没有任何特殊字符，只有字母和数字。提示：我正在使用sendTextMessage（）。