111 lines
4.7 KiB
Java
111 lines
4.7 KiB
Java
/*
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.google.android.vending.licensing;
|
|
|
|
import com.google.android.vending.licensing.util.Base64;
|
|
import com.google.android.vending.licensing.util.Base64DecoderException;
|
|
|
|
import java.io.UnsupportedEncodingException;
|
|
import java.security.GeneralSecurityException;
|
|
import java.security.spec.KeySpec;
|
|
|
|
import javax.crypto.BadPaddingException;
|
|
import javax.crypto.Cipher;
|
|
import javax.crypto.IllegalBlockSizeException;
|
|
import javax.crypto.SecretKey;
|
|
import javax.crypto.SecretKeyFactory;
|
|
import javax.crypto.spec.IvParameterSpec;
|
|
import javax.crypto.spec.PBEKeySpec;
|
|
import javax.crypto.spec.SecretKeySpec;
|
|
|
|
/**
|
|
* An Obfuscator that uses AES to encrypt data.
|
|
*/
|
|
public class AESObfuscator implements Obfuscator {
|
|
private static final String UTF8 = "UTF-8";
|
|
private static final String KEYGEN_ALGORITHM = "PBEWITHSHAAND256BITAES-CBC-BC";
|
|
private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS5Padding";
|
|
private static final byte[] IV =
|
|
{ 16, 74, 71, -80, 32, 101, -47, 72, 117, -14, 0, -29, 70, 65, -12, 74 };
|
|
private static final String header = "com.android.vending.licensing.AESObfuscator-1|";
|
|
|
|
private Cipher mEncryptor;
|
|
private Cipher mDecryptor;
|
|
|
|
/**
|
|
* @param salt an array of random bytes to use for each (un)obfuscation
|
|
* @param applicationId application identifier, e.g. the package name
|
|
* @param deviceId device identifier. Use as many sources as possible to
|
|
* create this unique identifier.
|
|
*/
|
|
public AESObfuscator(byte[] salt, String applicationId, String deviceId) {
|
|
try {
|
|
SecretKeyFactory factory = SecretKeyFactory.getInstance(KEYGEN_ALGORITHM);
|
|
KeySpec keySpec =
|
|
new PBEKeySpec((applicationId + deviceId).toCharArray(), salt, 1024, 256);
|
|
SecretKey tmp = factory.generateSecret(keySpec);
|
|
SecretKey secret = new SecretKeySpec(tmp.getEncoded(), "AES");
|
|
mEncryptor = Cipher.getInstance(CIPHER_ALGORITHM);
|
|
mEncryptor.init(Cipher.ENCRYPT_MODE, secret, new IvParameterSpec(IV));
|
|
mDecryptor = Cipher.getInstance(CIPHER_ALGORITHM);
|
|
mDecryptor.init(Cipher.DECRYPT_MODE, secret, new IvParameterSpec(IV));
|
|
} catch (GeneralSecurityException e) {
|
|
// This can't happen on a compatible Android device.
|
|
throw new RuntimeException("Invalid environment", e);
|
|
}
|
|
}
|
|
|
|
public String obfuscate(String original, String key) {
|
|
if (original == null) {
|
|
return null;
|
|
}
|
|
try {
|
|
// Header is appended as an integrity check
|
|
return Base64.encode(mEncryptor.doFinal((header + key + original).getBytes(UTF8)));
|
|
} catch (UnsupportedEncodingException e) {
|
|
throw new RuntimeException("Invalid environment", e);
|
|
} catch (GeneralSecurityException e) {
|
|
throw new RuntimeException("Invalid environment", e);
|
|
}
|
|
}
|
|
|
|
public String unobfuscate(String obfuscated, String key) throws ValidationException {
|
|
if (obfuscated == null) {
|
|
return null;
|
|
}
|
|
try {
|
|
String result = new String(mDecryptor.doFinal(Base64.decode(obfuscated)), UTF8);
|
|
// Check for presence of header. This serves as a final integrity check, for cases
|
|
// where the block size is correct during decryption.
|
|
int headerIndex = result.indexOf(header+key);
|
|
if (headerIndex != 0) {
|
|
throw new ValidationException("Header not found (invalid data or key)" + ":" +
|
|
obfuscated);
|
|
}
|
|
return result.substring(header.length()+key.length(), result.length());
|
|
} catch (Base64DecoderException e) {
|
|
throw new ValidationException(e.getMessage() + ":" + obfuscated);
|
|
} catch (IllegalBlockSizeException e) {
|
|
throw new ValidationException(e.getMessage() + ":" + obfuscated);
|
|
} catch (BadPaddingException e) {
|
|
throw new ValidationException(e.getMessage() + ":" + obfuscated);
|
|
} catch (UnsupportedEncodingException e) {
|
|
throw new RuntimeException("Invalid environment", e);
|
|
}
|
|
}
|
|
}
|