blob: 4aec509e9d87776e32f118b44ca6bf3e3dd9cd11 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
package cgeo.geocaching.utils;
import org.apache.commons.lang3.CharEncoding;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.jdt.annotation.NonNull;
import android.text.Spannable;
import android.text.SpannableStringBuilder;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.GeneralSecurityException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
public final class CryptUtils {
private CryptUtils() {
// utility class
}
private static final byte[] EMPTY = {};
private static final char[] BASE64MAP1 = new char[64];
private static final byte[] BASE64MAP2 = new byte[128];
static {
int i = 0;
for (char c = 'A'; c <= 'Z'; c++) {
BASE64MAP1[i++] = c;
}
for (char c = 'a'; c <= 'z'; c++) {
BASE64MAP1[i++] = c;
}
for (char c = '0'; c <= '9'; c++) {
BASE64MAP1[i++] = c;
}
BASE64MAP1[i++] = '+';
BASE64MAP1[i++] = '/';
for (i = 0; i < BASE64MAP2.length; i++) {
BASE64MAP2[i] = -1;
}
for (i = 0; i < 64; i++) {
BASE64MAP2[BASE64MAP1[i]] = (byte) i;
}
}
private static class Rot13Encryption {
private boolean plaintext = false;
char getNextEncryptedCharacter(final char c) {
int result = c;
if (result == '[') {
plaintext = true;
} else if (result == ']') {
plaintext = false;
} else if (!plaintext) {
final int capitalized = result & 32;
result &= ~capitalized;
result = ((result >= 'A') && (result <= 'Z') ? ((result - 'A' + 13) % 26 + 'A') : result)
| capitalized;
}
return (char) result;
}
}
@NonNull
public static String rot13(final String text) {
if (text == null) {
return StringUtils.EMPTY;
}
final StringBuilder result = new StringBuilder();
final Rot13Encryption rot13 = new Rot13Encryption();
final int length = text.length();
for (int index = 0; index < length; index++) {
final char c = text.charAt(index);
result.append(rot13.getNextEncryptedCharacter(c));
}
return result.toString();
}
public static String md5(final String text) {
try {
final MessageDigest digest = MessageDigest.getInstance("MD5");
digest.update(text.getBytes(CharEncoding.UTF_8), 0, text.length());
return new BigInteger(1, digest.digest()).toString(16);
} catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
Log.e("CryptUtils.md5", e);
}
return StringUtils.EMPTY;
}
public static byte[] hashHmac(final String text, final String salt) {
try {
final SecretKeySpec secretKeySpec = new SecretKeySpec(salt.getBytes(CharEncoding.UTF_8), "HmacSHA1");
final Mac mac = Mac.getInstance("HmacSHA1");
mac.init(secretKeySpec);
return mac.doFinal(text.getBytes(CharEncoding.UTF_8));
} catch (GeneralSecurityException | UnsupportedEncodingException e) {
Log.e("CryptUtils.hashHmac", e);
return EMPTY;
}
}
public static CharSequence rot13(final Spannable span) {
// I needed to re-implement the rot13(String) encryption here because we must work on
// a SpannableStringBuilder instead of the pure text and we must replace each character inline.
// Otherwise we loose all the images, colors and so on...
final SpannableStringBuilder buffer = new SpannableStringBuilder(span);
final Rot13Encryption rot13 = new Rot13Encryption();
final int length = span.length();
for (int index = 0; index < length; index++) {
final char c = span.charAt(index);
buffer.replace(index, index + 1, String.valueOf(rot13.getNextEncryptedCharacter(c)));
}
return buffer;
}
public static String base64Encode(final byte[] in) {
final int iLen = in.length;
final int oDataLen = (iLen * 4 + 2) / 3; // output length without padding
final int oLen = ((iLen + 2) / 3) * 4; // output length including padding
final char[] out = new char[oLen];
int ip = 0;
int op = 0;
while (ip < iLen) {
final int i0 = in[ip++] & 0xff;
final int i1 = ip < iLen ? in[ip++] & 0xff : 0;
final int i2 = ip < iLen ? in[ip++] & 0xff : 0;
final int o0 = i0 >>> 2;
final int o1 = ((i0 & 3) << 4) | (i1 >>> 4);
final int o2 = ((i1 & 0xf) << 2) | (i2 >>> 6);
final int o3 = i2 & 0x3F;
out[op++] = BASE64MAP1[o0];
out[op++] = BASE64MAP1[o1];
out[op] = op < oDataLen ? BASE64MAP1[o2] : '=';
op++;
out[op] = op < oDataLen ? BASE64MAP1[o3] : '=';
op++;
}
return new String(out);
}
}
|
