@Test
public void testEncodeString() {
final String text = "--- abcdefg \r\n hijklmn \t opqrst \u3000 uvwxyz ---";
String base64 = Base64Util.encodeString(text);
String restore = Base64Util.decodeString(base64);
assertEquals(text, restore);
}
@Test
public void testEncode() {
final byte[] data = "abcdefg \r\n hijklmn \t opqrst \u3000 uvwxyz".getBytes();
String base64 = Base64Util.encode(data);
byte[] restore = Base64Util.decode(base64);
assertEquals(data.length, restore.length);
for (int i = 0; i < data.length; i++) {
assertEquals(data[i], restore[i]);
}
}
@Test
public void randomTest() {
final Random rnd = new Random();
final int cnt = 10;
final int maxSize = 1024;
for (int i = 0; i < cnt; i++) {
for (int j = 0; j < maxSize; j++) {
final byte[] data = new byte[j];
rnd.nextBytes(data);
final String encstr = Base64Util.encode(data);
final byte[] decoded = Base64Util.decode(encstr);
Assert.assertArrayEquals(data, decoded);
}
}
}
private static String csr() {
try {
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
keyGen.initialize(2048);
KeyPair keyPair = keyGen.generateKeyPair();
X500Principal subject =
new X500Principal(
"CN = edea87b4-034d-48dc-94dd-e7cdcfdde370/10562468, OU = fgdfgretertgdfg, O = VW, L = US");
ContentSigner signer = new JcaContentSignerBuilder("SHA1withRSA").build(keyPair.getPrivate());
PKCS10CertificationRequestBuilder builder =
new JcaPKCS10CertificationRequestBuilder(subject, keyPair.getPublic());
PKCS10CertificationRequest csr = builder.build(signer);
String type = "CERTIFICATE REQUEST";
PemObject pem = new PemObject(type, csr.getEncoded());
StringWriter str = new StringWriter();
PEMWriter pemWriter = new PEMWriter(str);
pemWriter.writeObject(pem);
pemWriter.close();
str.close();
Log.d("Test", "" + str);
return Base64Util.getStringAsBase64(str.toString());
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (OperatorCreationException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return "";
}
/**
* @param strKey key
* @param strIvKey 矢量key
* @param strContent 要解密的内容
* @return 加密后的字符串，失败返回null
*/
public static String encode(String strKey, String strIvKey, String strContent) {
IvParameterSpec zeroIv = new IvParameterSpec(strIvKey.getBytes());
SecretKeySpec key = new SecretKeySpec(strKey.getBytes(), "AES");
Cipher cipher;
byte[] encryptedData = null;
try {
cipher = Cipher.getInstance(TRANSFORMATION);
cipher.init(Cipher.ENCRYPT_MODE, key, zeroIv);
encryptedData = cipher.doFinal(strContent.getBytes(CHARSET));
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidAlgorithmParameterException e) {
e.printStackTrace();
Log.e(TAG, "无效的矢量key");
} catch (InvalidKeyException e) {
e.printStackTrace();
Log.e(TAG, "无效的key");
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
if (encryptedData == null) {
return null;
}
return Base64Util.encode(encryptedData);
}
/**
* Parse to a ProtocolHashedVersion from a given string version/base64-hash combination.
*
* @param startVersion the starting version
* @param base64Hash the base64 hash
* @throws IllegalArgumentException on bad data
* @return a parsed protobuf object
*/
private static ProtocolHashedVersion parseFromUnsafe(String startVersion, String base64Hash)
throws IllegalArgumentException {
return ProtocolHashedVersion.newBuilder()
.setVersion(Long.parseLong(startVersion))
.setHistoryHash(Base64Util.decode(base64Hash))
.build();
}
@Test
public void decodeBig() {
byte[] res =
Base64Util.decode(
"TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNldGV0dXIgc2FkaXBzY2luZyBlbGl0ciwg\n"
+ "c2VkIGRpYW0gbm9udW15IGVpcm1vZCB0ZW1wb3IgaW52aWR1bnQgdXQgbGFib3JlIGV0IGRvbG9y\n"
+ "ZSBtYWduYSBhbGlxdXlhbSBlcmF0LCBzZWQgZGlhbSB2b2x1cHR1YS4gQXQgdmVybyBlb3MgZXQg\n"
+ "YWNjdXNhbSBldCBqdXN0byBkdW8gZG9sb3JlcyBldCBlYSByZWJ1bS4gU3RldCBjbGl0YSBrYXNk\n"
+ "IGd1YmVyZ3Jlbiwgbm8gc2VhIHRha2ltYXRhIHNhbmN0dXMgZXN0IExvcmVtIGlwc3VtIGRvbG9y\n"
+ "IHNpdCBhbWV0LiBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2V0ZXR1ciBzYWRpcHNj\n"
+ "aW5nIGVsaXRyLCBzZWQgZGlhbSBub251bXkgZWlybW9kIHRlbXBvciBpbnZpZHVudCB1dCBsYWJv\n"
+ "cmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1eWFtIGVyYXQsIHNlZCBkaWFtIHZvbHVwdHVhLiBBdCB2\n"
+ "ZXJvIGVvcyBldCBhY2N1c2FtIGV0IGp1c3RvIGR1byBkb2xvcmVzIGV0IGVhIHJlYnVtLiBTdGV0\n"
+ "IGNsaXRhIGthc2QgZ3ViZXJncmVuLCBubyBzZWEgdGFraW1hdGEgc2FuY3R1cyBlc3QgTG9yZW0g\n"
+ "aXBzdW0gZG9sb3Igc2l0IGFtZXQuIDEyMzQ1IS84Ly8vMzQ1KiY=");
assertEquals(
new String(res),
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod "
+ "tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero "
+ "eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata "
+ "sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing "
+ "elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed "
+ "diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd "
+ "gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. 12345!/8///345*&");
}
public static String down(String imgURL, String fmt) throws Exception {
// byte[] streamToByte = streamToByte(new URL(imgURL).openStream());
byte[] streamToByte = streamToByte(new URL(imgURL).openStream(), fmt);
// for (byte b : streamToByte) {
// System.out.println( " ** "+b);
// }
return Base64Util.encode(streamToByte);
}
public static String encryptPassword(String decPwd, Integer userId) throws Exception {
String encPwd = null;
String passwordToGenKey = "IUSER" + userId;
// Obtener el texto que va a dar el hash inicial
byte buf[] = passwordToGenKey.getBytes("ISO-8859-1");
Security.addProvider(new BouncyCastleProvider());
// Obtener el hash
MessageDigest md = MessageDigest.getInstance("MD5", "BC");
md.update(buf);
byte hash[] = md.digest();
// Aunque no lo diga en ninguna parte, el cryptoapi usa una clave de 128
// bits con todo ceros
// menos los 5 primeros bytes para cifrar....
byte newHash[] = {
(byte) hash[0],
(byte) hash[1],
(byte) hash[2],
(byte) hash[3],
(byte) hash[4],
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00
};
// Obtener la key basada en ese hash
SecretKeySpec key = new SecretKeySpec(newHash, "RC4");
// Obtener el objeto Cipher e inicializarlo con la key
Cipher cipher = Cipher.getInstance("RC4", "BC");
cipher.init(Cipher.ENCRYPT_MODE, key);
// Obtener los datos a cifrar
byte bufPlain[] = decPwd.getBytes("ISO-8859-1");
// cifrar
byte bufCipher[] = cipher.doFinal(bufPlain);
encPwd = Base64Util.encode(bufCipher);
return encPwd;
}
@Test
public void boundaryTest() {
final byte[][] testcases = {
makeArray(0, 0),
makeArray(1, 0),
makeArray(2, 0),
makeArray(1, 127),
makeArray(1, 128),
makeArray(1, 255),
makeArray(2, 127),
makeArray(2, 128),
makeArray(2, 255),
makeArray(3, 127),
makeArray(3, 128),
makeArray(3, 255),
};
for (byte[] data : testcases) {
final String encstr = Base64Util.encode(data);
final byte[] decoded = Base64Util.decode(encstr);
Assert.assertArrayEquals(data, decoded);
}
}
public static String decryptPasswordLDAP(String pwdLdap) throws Exception {
String passwordToGenKey = "IDOCLDAP";
byte dPasswordLDAP[] = Base64Util.decode(pwdLdap);
// Obtener el texto que va a dar el hash inicial
byte buf[] = passwordToGenKey.getBytes("ISO-8859-1");
Security.addProvider(new BouncyCastleProvider());
// Obtener el hash
MessageDigest md = MessageDigest.getInstance("MD5", "BC");
md.update(buf);
byte hash[] = md.digest();
// Aunque no lo diga en ninguna parte, el cryptoapi usa una clave de 128
// bits con todo ceros
// menos los 5 primeros bytes para cifrar....
byte newHash[] = {
(byte) hash[0],
(byte) hash[1],
(byte) hash[2],
(byte) hash[3],
(byte) hash[4],
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00
};
// Obtener la key basada en ese hash
SecretKeySpec key = new SecretKeySpec(newHash, "RC4");
// Obtener el objeto Cipher e inicializarlo con la key
Cipher cipher = Cipher.getInstance("RC4", "BC");
cipher.init(Cipher.DECRYPT_MODE, key);
// descifrar
byte bufCipher[] = cipher.doFinal(dPasswordLDAP);
String descPwdLdap = new String(bufCipher);
return descPwdLdap;
}
public static String toString(Object value, String pattern) {
if (value == null) {
return null;
} else if (value instanceof String) {
return (String) value;
} else if (value instanceof java.util.Date) {
return toString((java.util.Date) value, pattern);
} else if (value instanceof Number) {
return toString((Number) value, pattern);
} else if (value instanceof byte[]) {
return Base64Util.encode((byte[]) value);
} else {
return value.toString();
}
}
/**
* @param strKey key
* @param strIvKey 矢量key
* @param strContent 要解密的内容
* @return 解密后的字符串，失败返回null
*/
public static String decode(String strKey, String strIvKey, String strContent) {
byte[] byteMi = Base64Util.decode(strContent);
IvParameterSpec zeroIv = new IvParameterSpec(strIvKey.getBytes());
SecretKeySpec key = new SecretKeySpec(strKey.getBytes(), "AES");
Cipher cipher;
byte[] decodedData = null;
try {
cipher = Cipher.getInstance(TRANSFORMATION);
cipher.init(Cipher.DECRYPT_MODE, key, zeroIv);
decodedData = cipher.doFinal(byteMi);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (InvalidAlgorithmParameterException e) {
e.printStackTrace();
Log.e(TAG, "无效的矢量key");
} catch (InvalidKeyException e) {
e.printStackTrace();
Log.e(TAG, "无效的key");
}
String result = null;
if (decodedData == null) {
return null;
}
try {
result = new String(decodedData, CHARSET);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
Log.e(TAG, "无法把解密后的字符数组转化为" + CHARSET + "字符串");
}
return result;
}
@Test
public void decodeEmpty() {
assertEquals(Base64Util.decode("").length, 0);
}
/**
* Handles a submit request from a foreign wave remote. Sends it to the wave server, sets up a
* callback to send the response.
*
* @param request the submit request
* @param responseCallback the callback to send the response back
*/
void processSubmitRequest(final IQ request, final PacketCallback responseCallback) {
Element item = null, submitRequest = null, deltaElement = null;
Element pubsubRequest = request.getElement().element("pubsub");
// TODO: check for correct elements.
Element publish = pubsubRequest.element("publish");
if (publish != null) {
item = publish.element("item");
if (item != null) {
submitRequest = item.element("submit-request");
if (submitRequest != null) {
deltaElement = submitRequest.element("delta");
}
}
}
if (publish == null
|| item == null
|| submitRequest == null
|| deltaElement == null
|| deltaElement.attribute("wavelet-name") == null
|| deltaElement.getText() == null) {
responseCallback.error(FederationErrors.badRequest("Malformed submit request"));
return;
}
final WaveletName waveletName;
try {
waveletName =
XmppUtil.waveletNameCodec.uriToWaveletName(deltaElement.attributeValue("wavelet-name"));
} catch (EncodingException e) {
responseCallback.error(
FederationErrors.badRequest(
"Malformed wavelet name: " + deltaElement.attributeValue("wavelet-name")));
return;
}
final ProtocolSignedDelta delta;
try {
delta = ProtocolSignedDelta.parseFrom(Base64Util.decode(deltaElement.getText()));
} catch (InvalidProtocolBufferException e) {
responseCallback.error(
FederationErrors.badRequest("Malformed delta, not a valid protocol buffer"));
return;
}
// Construct a submit result listener inline.
WaveletFederationProvider.SubmitResultListener listener =
new WaveletFederationProvider.SubmitResultListener() {
@Override
public void onFailure(FederationError error) {
responseCallback.error(error);
}
@Override
public void onSuccess(int operations, ProtocolHashedVersion version, long timestamp) {
IQ response = IQ.createResultIQ(request);
Element pubsub = response.setChildElement("pubsub", XmppNamespace.NAMESPACE_PUBSUB);
Element submitResponse =
pubsub
.addElement("publish")
.addElement("item")
.addElement("submit-response", XmppNamespace.NAMESPACE_WAVE_SERVER);
submitResponse.addAttribute("application-timestamp", String.valueOf(timestamp));
submitResponse.addAttribute("operations-applied", String.valueOf(operations));
Element hashedVersion = submitResponse.addElement("hashed-version");
hashedVersion.addAttribute("history-hash", Base64Util.encode(version.getHistoryHash()));
hashedVersion.addAttribute("version", String.valueOf(version.getVersion()));
responseCallback.run(response);
}
};
// Hand off the submit request to the wavelet provider.
waveletProvider.submitRequest(waveletName, delta, listener);
}
public static String down(String imgURL) throws Exception {
byte[] streamToByte = streamToByte(new URL(imgURL).openStream());
return Base64Util.encode(streamToByte);
}
/**
* Reads a get signer request off the wire, sends it to the WS with a new callback for returning
* the response.
*
* @param request the get signer request
* @param responseCallback the callback to send the response back
*/
void processGetSignerRequest(final IQ request, final PacketCallback responseCallback) {
Element items = request.getChildElement().element("items");
Element signerRequest = items != null ? items.element("signer-request") : null;
if (items == null
|| signerRequest == null
|| signerRequest.attributeValue("wavelet-name") == null
|| signerRequest.attributeValue("signer-id") == null
|| signerRequest.attributeValue("version") == null
|| signerRequest.attributeValue("history-hash") == null) {
manager.sendErrorResponse(request, FederationErrors.badRequest("Malformed signer request"));
return;
}
final ByteString signerId;
try {
signerId = Base64Util.decode(signerRequest.attributeValue("signer-id"));
} catch (IllegalArgumentException e) {
responseCallback.error(FederationErrors.badRequest("Malformed signer ID"));
return;
}
final ProtocolHashedVersion deltaEndVersion;
try {
deltaEndVersion =
parseFromUnsafe(
signerRequest.attributeValue("version"),
signerRequest.attributeValue("history-hash"));
} catch (IllegalArgumentException e) {
responseCallback.error(FederationErrors.badRequest("Invalid hashed version"));
return;
}
final WaveletName waveletName;
try {
waveletName =
XmppUtil.waveletNameCodec.uriToWaveletName(signerRequest.attributeValue("wavelet-name"));
} catch (EncodingException e) {
responseCallback.error(FederationErrors.badRequest("Malformed wavelet name"));
return;
}
WaveletFederationProvider.DeltaSignerInfoResponseListener listener =
new WaveletFederationProvider.DeltaSignerInfoResponseListener() {
@Override
public void onFailure(FederationError error) {
responseCallback.error(error);
}
@Override
public void onSuccess(ProtocolSignerInfo signerInfo) {
IQ response = IQ.createResultIQ(request);
Element pubsub = response.setChildElement("pubsub", XmppNamespace.NAMESPACE_PUBSUB);
Element items = pubsub.addElement("items");
XmppUtil.protocolSignerInfoToXml(signerInfo, items);
responseCallback.run(response);
}
};
waveletProvider.getDeltaSignerInfo(signerId, waveletName, deltaEndVersion, listener);
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void decodeNull() {
Base64Util.decode(null);
}
@Test
public void testDecodeBadBase64() {
final String base64 = "ABCDEFG@@@\u3000\n\n@@..=";
assertNull(Base64Util.decode(base64));
}
public static String encryptHashDocument(byte[] data) throws Exception {
String encPwd = null;
String passwordToGenKey = "IUSER0";
byte[] buffer;
Security.addProvider(new BouncyCastleProvider());
MessageDigest gen = MessageDigest.getInstance("SHA-256", "BC");
gen.update(data, 0, data.length);
buffer = gen.digest();
// ////////////////////////
String buffer1 = Base64Util.encode(buffer);
// ///////////////////////
// Obtener el texto que va a dar el hash inicial
byte buf[] = passwordToGenKey.getBytes("ISO-8859-1");
// Obtener el hash
MessageDigest md = MessageDigest.getInstance("MD5", "BC");
md.update(buf);
byte hash[] = md.digest();
// Aunque no lo diga en ninguna parte, el cryptoapi usa una clave de 128
// bits con todo ceros
// menos los 5 primeros bytes para cifrar....
byte newHash[] = {
(byte) hash[0],
(byte) hash[1],
(byte) hash[2],
(byte) hash[3],
(byte) hash[4],
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00
};
// Obtener la key basada en ese hash
SecretKeySpec key = new SecretKeySpec(newHash, "RC4");
// Obtener el objeto Cipher e inicializarlo con la key
Cipher cipher = Cipher.getInstance("RC4", "BC");
cipher.init(Cipher.ENCRYPT_MODE, key);
// cifrar
// byte bufCipher[] = cipher.doFinal(buffer);
// ///////////////////////////////
byte bufCipher[] = cipher.doFinal(buffer1.getBytes());
// ///////////////////////////////
encPwd = Base64Util.encode(bufCipher);
return encPwd;
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void decodeToSmall() {
assertEquals(Base64Util.decode("abc").length, 0);
}
