public static void logTokens(Activity context) { // Add code to print out the key hash try { PackageInfo info = context .getPackageManager() .getPackageInfo( context.getApplicationContext().getPackageName(), PackageManager.GET_SIGNATURES); for (Signature signature : info.signatures) { MessageDigest md = MessageDigest.getInstance("SHA-1"); md.update(signature.toByteArray()); Log.d("SHA-KeyHash:::", Base64.encodeToString(md.digest(), Base64.DEFAULT)); md = MessageDigest.getInstance("MD5"); md.update(signature.toByteArray()); Log.d("MD5-KeyHash:::", Base64.encodeToString(md.digest(), Base64.DEFAULT)); md = MessageDigest.getInstance("SHA"); md.update(signature.toByteArray()); Log.d("SHA-Hex-From-KeyHash:::", bytesToHex(md.digest())); } } catch (NameNotFoundException e) { } catch (NoSuchAlgorithmException e) { } }
/** * Returns true if the given values match the commitment given. * * @param commitment * @param value * @param randomness * @return */ public static boolean checkCommitment( MessageDigest H, BigInteger commitment, BigInteger value, BigInteger randomness) { H.update(value.toByteArray()); H.update(randomness.toByteArray()); BigInteger testSubject = new BigInteger(H.digest()).mod(Util.getModulus()); return commitment.equals(testSubject); }
private static void appendArray(MessageDigest digest, Object value) { digest.update("A".getBytes()); for (int i = 0; i < Array.getLength(value); i++) { appendObject(digest, Array.get(value, i)); digest.update(",".getBytes()); } }
/** * 对报文进行采用MD5进行hmac签名 * * @param aValue - 字符�? * @param aKey - 密钥 * @param encoding - 字符串编码方�? * @return - 签名结果,hex字符�? */ public static String hmacSign(String aValue, String aKey, String encoding) { byte k_ipad[] = new byte[64]; byte k_opad[] = new byte[64]; byte keyb[]; byte value[]; try { keyb = aKey.getBytes(encoding); value = aValue.getBytes(encoding); } catch (UnsupportedEncodingException e) { keyb = aKey.getBytes(); value = aValue.getBytes(); } Arrays.fill(k_ipad, keyb.length, 64, (byte) 54); Arrays.fill(k_opad, keyb.length, 64, (byte) 92); for (int i = 0; i < keyb.length; i++) { k_ipad[i] = (byte) (keyb[i] ^ 0x36); k_opad[i] = (byte) (keyb[i] ^ 0x5c); } MessageDigest md = null; try { md = MessageDigest.getInstance("MD5"); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); return null; } md.update(k_ipad); md.update(value); byte dg[] = md.digest(); md.reset(); md.update(k_opad); md.update(dg, 0, 16); dg = md.digest(); return ConvertUtils.toHex(dg); }
/** * Computes the serial version UID value for the given class. The code is taken from {@link * ObjectStreamClass#computeDefaultSUID(Class)}. * * @param cls A class. * @return A serial version UID. * @throws IOException If failed. */ static long computeSerialVersionUid(Class cls) throws IOException { if (Serializable.class.isAssignableFrom(cls) && !Enum.class.isAssignableFrom(cls)) { return ObjectStreamClass.lookup(cls).getSerialVersionUID(); } MessageDigest md; try { md = MessageDigest.getInstance("SHA"); } catch (NoSuchAlgorithmException e) { throw new IOException("Failed to get digest for SHA.", e); } md.update(cls.getName().getBytes(UTF_8)); for (Field f : getFieldsForSerialization(cls)) { md.update(f.getName().getBytes(UTF_8)); md.update(f.getType().getName().getBytes(UTF_8)); } byte[] hashBytes = md.digest(); long hash = 0; // Composes a single-long hash from the byte[] hash. for (int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--) hash = (hash << 8) | (hashBytes[i] & 0xFF); return hash; }
/** * @param key * @param update_key * @return * @throws CryptoException */ public byte[] update(byte[] key, byte[] update_key) throws CryptoException { byte[] shasig = new byte[20]; byte[] update = new byte[this.keylength]; // changed from 8 - rdesktop // 1.2.0 byte[] thekey = new byte[key.length]; synchronized (digestLock) { sha1.reset(); sha1.update(update_key, 0, keylength); sha1.update(pad_54, 0, 40); sha1.update(key, 0, keylength); // changed from 8 - rdesktop // 1.2.0 shasig = sha1.digest(); sha1.reset(); md5.reset(); md5.update(update_key, 0, keylength); // changed from 8 - rdesktop // 1.2.0 md5.update(pad_92, 0, 48); md5.update(shasig, 0, 20); thekey = md5.digest(); md5.reset(); System.arraycopy(thekey, 0, update, 0, this.keylength); rc4_update.engineInitDecrypt(update); // added thekey = rc4_update.crypt(thekey, 0, this.keylength); if (this.keylength == 8) { this.make40bit(thekey); } } return thekey; }
/** * Generate the mask. * * @param seed source of input bytes for initial digest state * @param length length of mask to generate * @return a byte array containing a MGF1 generated mask */ public byte[] generateMask(byte[] seed, int length) { byte[] mask = new byte[length]; byte[] C = new byte[4]; int counter = 0; int hLen = digest.getDigestLength(); digest.reset(); while (counter < (length / hLen)) { ItoOSP(counter, C); digest.update(seed); digest.update(C); System.arraycopy(digest.digest(), 0, mask, counter * hLen, hLen); counter++; } if ((counter * hLen) < length) { ItoOSP(counter, C); digest.update(seed); digest.update(C); System.arraycopy(digest.digest(), 0, mask, counter * hLen, mask.length - (counter * hLen)); } return mask; }
/** * Calculates the hash of password (and salt bytes, if supplied) and returns a base64 encoded * concatenation of the hash and salt, prefixed with {SHA} (or {SSHA} if salt was used). * * @param rawPass the password to be encoded. * @param salt the salt. Must be a byte array or null. * @return the encoded password in the specified format */ public String encodePassword(String rawPass, Object salt) { MessageDigest sha; try { sha = MessageDigest.getInstance("SHA"); sha.update(rawPass.getBytes("UTF-8")); } catch (java.security.NoSuchAlgorithmException e) { throw new IllegalStateException("No SHA implementation available!"); } catch (UnsupportedEncodingException ue) { throw new IllegalStateException("UTF-8 not supported!"); } if (salt != null) { Assert.isInstanceOf(byte[].class, salt, "Salt value must be a byte array"); sha.update((byte[]) salt); } byte[] hash = combineHashAndSalt(sha.digest(), (byte[]) salt); String prefix; if (salt == null) { prefix = forceLowerCasePrefix ? SHA_PREFIX_LC : SHA_PREFIX; } else { prefix = forceLowerCasePrefix ? SSHA_PREFIX_LC : SSHA_PREFIX; } return prefix + new String(Base64.encode(hash)); }
private byte[] createRFC2617RequestDigest( final byte[] ha1, final byte[] ha2, final DigestContext context) { final MessageDigest digest = context.getDigest(); final Map<DigestAuthorizationToken, String> parsedHeader = context.getParsedHeader(); byte[] nonce = parsedHeader.get(DigestAuthorizationToken.NONCE).getBytes(StandardCharsets.UTF_8); byte[] nonceCount = parsedHeader.get(DigestAuthorizationToken.NONCE_COUNT).getBytes(StandardCharsets.UTF_8); byte[] cnonce = parsedHeader.get(DigestAuthorizationToken.CNONCE).getBytes(StandardCharsets.UTF_8); byte[] qop = parsedHeader.get(DigestAuthorizationToken.MESSAGE_QOP).getBytes(StandardCharsets.UTF_8); try { digest.update(ha1); digest.update(COLON); digest.update(nonce); digest.update(COLON); digest.update(nonceCount); digest.update(COLON); digest.update(cnonce); digest.update(COLON); digest.update(qop); digest.update(COLON); digest.update(ha2); return HexConverter.convertToHexBytes(digest.digest()); } finally { digest.reset(); } }
/** * Completes the Mac computation and resets the Mac for further use, maintaining the secret key * that the Mac was initialized with. * * @return the Mac result. */ byte[] doFinal() { if (first == true) { // compute digest for 1st pass; start with inner pad md.update(secret); md.update(pad1); } else { first = true; } try { // finish the inner digest byte[] tmp = md.digest(); // compute digest for 2nd pass; start with outer pad md.update(secret); md.update(pad2); // add result of 1st hash md.update(tmp); md.digest(tmp, 0, tmp.length); return tmp; } catch (DigestException e) { // should never occur throw new ProviderException(e); } }
public String calculateHash(String graph) throws SQLException, NoSuchAlgorithmException { // TODO: sanitize graph MessageDigest digest = MessageDigest.getInstance("SHA-512"); // takes 50 sec on Fly data // MessageDigest digest = MessageDigest.getInstance("MD5"); // takes 46 sec on Fly data // cb66cc5f1feb5169542af48342936ad2962a8ae14840f1e029028636004f779346c19ecd0917ea2f53c6ec94f4ab10c5bffc272888ae33b73797bdee9cb7193a Statement st = con.createStatement(); try { ResultSet rs = executeQuery(st, "SPARQL SELECT ?s ?p ?o FROM <" + graph + "> WHERE { ?s ?p ?o . }"); while (rs.next()) { digest.update(rs.getString(1).getBytes()); digest.update(rs.getString(2).getBytes()); digest.update(rs.getString(3).getBytes()); } } catch (VirtuosoException ex) { rethrowWithTips(ex); } String hexString = new String(Hex.encodeHex(digest.digest())); return hexString; }
/** * Flush and invoke appropriate optype * * @param optype the optype * @param index the index * @param type the type * @param id the id * @throws IOException */ public void flush(String optype, String index, String type, String id) throws IOException { if (!map.isEmpty()) { build(map); if (listener != null) { if ("create".equals(optype)) { listener.create(index, type, id, version, builder); } else if ("index".equals(optype)) { listener.index(index, type, id, version, builder); } else if ("delete".equals(optype)) { listener.delete(index, type, id); } } if (index != null) { digest.update(index.getBytes("UTF-8")); } if (type != null) { digest.update(type.getBytes("UTF-8")); } if (id != null) { digest.update(id.getBytes("UTF-8")); } builder.close(); builder = jsonBuilder(); map = new HashMap(); } }
boolean isManifestUpdated() { if (!mCacheFile.exists()) { Log.i("ManifestCheckerService", "updated: cache file does not exist"); return true; } try { MessageDigest dataDigester = MessageDigest.getInstance("MD5"); dataDigester.update(mFetcher.getData(), 0, mFetcher.getDataLen()); byte[] dataDigest = dataDigester.digest(); MessageDigest fileDigester = MessageDigest.getInstance("MD5"); FileInputStream is = new FileInputStream(mCacheFile); byte[] buf = new byte[4096]; int len; while ((len = is.read(buf)) > 0) { fileDigester.update(buf, 0, len); } is.close(); byte[] fileDigest = fileDigester.digest(); if (Arrays.equals(dataDigest, fileDigest)) { return false; } Log.i("ManifestCheckerService", "updated: digests differ"); } catch (Exception e) { Log.e("ManifestFetcher", "caught exception: " + e.getMessage()); e.printStackTrace(); } return true; }
private boolean verify( Attributes attributes, String entry, byte[] data, int start, int end, boolean ignoreSecondEndline, boolean ignorable) { for (int i = 0; i < DIGEST_ALGORITHMS.length; i++) { String algorithm = DIGEST_ALGORITHMS[i]; String hash = attributes.getValue(algorithm + entry); if (hash == null) { continue; } MessageDigest md; try { md = MessageDigest.getInstance(algorithm); } catch (NoSuchAlgorithmException e) { continue; } if (ignoreSecondEndline && data[end - 1] == '\n' && data[end - 2] == '\n') { md.update(data, start, end - 1 - start); } else { md.update(data, start, end - start); } byte[] b = md.digest(); byte[] hashBytes = hash.getBytes(StandardCharsets.ISO_8859_1); return MessageDigest.isEqual(b, Base64.decode(hashBytes)); } return ignorable; }
private String hash(String clearPassword) { if (salt == 0) return null; MessageDigest md = null; try { md = MessageDigest.getInstance("SHA1"); } catch (NoSuchAlgorithmException e) { throw new AssertionError("Can't find the SHA1 algorithm in the java.security package"); } String saltString = String.valueOf(salt); md.update(saltString.getBytes()); md.update(clearPassword.getBytes()); byte[] digestBytes = md.digest(); // Format the digest as a String StringBuffer digestSB = new StringBuffer(); for (int i = 0; i < digestBytes.length; i++) { int lowNibble = digestBytes[i] & 0x0f; int highNibble = (digestBytes[i] >> 4) & 0x0f; digestSB.append(Integer.toHexString(highNibble)); digestSB.append(Integer.toHexString(lowNibble)); } String digestStr = digestSB.toString(); return digestStr; }
/** * 验证口令是否合法 * * @param password * @param passwordInDb * @return * @throws NoSuchAlgorithmException * @throws UnsupportedEncodingException */ public static boolean validPassword(String password, String passwordInDb) throws NoSuchAlgorithmException, UnsupportedEncodingException { // 将16进制字符串格式口令转换成字节数组 byte[] pwdInDb = hexStringToByte(passwordInDb); // 声明盐变量 byte[] salt = new byte[SALT_LENGTH]; // 将盐从数据库中保存的口令字节数组中提取出来 System.arraycopy(pwdInDb, 0, salt, 0, SALT_LENGTH); // 创建消息摘要对象 MessageDigest md = MessageDigest.getInstance("MD5"); // 将盐数据传入消息摘要对象 md.update(salt); // 将口令的数据传给消息摘要对象 md.update(password.getBytes("UTF-8")); // 生成输入口令的消息摘要 byte[] digest = md.digest(); // 声明一个保存数据库中口令消息摘要的变量 byte[] digestInDb = new byte[pwdInDb.length - SALT_LENGTH]; // 取得数据库中口令的消息摘要 System.arraycopy(pwdInDb, SALT_LENGTH, digestInDb, 0, digestInDb.length); // 比较根据输入口令生成的消息摘要和数据库中消息摘要是否相同 if (Arrays.equals(digest, digestInDb)) { // 口令正确返回口令匹配消息 return true; } else { // 口令不正确返回口令不匹配消息 return false; } }
/** * create from an issuer certificate and the serial number of the certificate it signed. * * @exception OCSPException if any problems occur creating the id fields. */ public CertificateID( String hashAlgorithm, X509Certificate issuerCert, BigInteger number, String provider) throws OCSPException { try { MessageDigest digest = MessageDigest.getInstance(hashAlgorithm, provider); AlgorithmIdentifier hashAlg = new AlgorithmIdentifier(new DERObjectIdentifier(hashAlgorithm), new DERNull()); X509Principal issuerName = PrincipalUtil.getSubjectX509Principal(issuerCert); digest.update(issuerName.getEncoded()); ASN1OctetString issuerNameHash = new DEROctetString(digest.digest()); PublicKey issuerKey = issuerCert.getPublicKey(); ASN1InputStream aIn = new ASN1InputStream(issuerKey.getEncoded()); SubjectPublicKeyInfo info = SubjectPublicKeyInfo.getInstance(aIn.readObject()); digest.update(info.getPublicKeyData().getBytes()); ASN1OctetString issuerKeyHash = new DEROctetString(digest.digest()); DERInteger serialNumber = new DERInteger(number); this.id = new CertID(hashAlg, issuerNameHash, issuerKeyHash, serialNumber); } catch (Exception e) { throw new OCSPException("problem creating ID: " + e, e); } }
/** * 获得加密后的16进制形式口令 * * @param password * @return * @throws NoSuchAlgorithmException * @throws UnsupportedEncodingException */ public static String getEncryptedPwd(String password) throws NoSuchAlgorithmException, UnsupportedEncodingException { // 声明加密后的口令数组变量 byte[] pwd = null; // 随机数生成器 SecureRandom random = new SecureRandom(); // 声明盐数组变量 byte[] salt = new byte[SALT_LENGTH]; // 将随机数放入盐变量中 random.nextBytes(salt); // 声明消息摘要对象 MessageDigest md = null; // 创建消息摘要 md = MessageDigest.getInstance("MD5"); // 将盐数据传入消息摘要对象 md.update(salt); // 将口令的数据传给消息摘要对象 md.update(password.getBytes("UTF-8")); // 获得消息摘要的字节数组 byte[] digest = md.digest(); // 因为要在口令的字节数组中存放盐,所以加上盐的字节长度 pwd = new byte[digest.length + SALT_LENGTH]; // 将盐的字节拷贝到生成的加密口令字节数组的前12个字节,以便在验证口令时取出盐 System.arraycopy(salt, 0, pwd, 0, SALT_LENGTH); // 将消息摘要拷贝到加密口令字节数组从第13个字节开始的字节 System.arraycopy(digest, 0, pwd, SALT_LENGTH, digest.length); // 将字节数组格式加密后的口令转化为16进制字符串格式的口令 return byteToHexString(pwd); }
/* goodG2B2() - use goodsource and badsink by reversing statements in first if */ private void goodG2B2() throws Throwable { String data; /* INCIDENTAL: CWE 571 Statement is Always True */ if (private_final_t) { java.util.logging.Logger log_good = java.util.logging.Logger.getLogger("local-logger"); /* FIX: Use a hardcoded string */ data = "foo"; } else { /* INCIDENTAL: CWE 561 Dead Code, the code below will never run */ Logger log_bad = Logger.getLogger("local-logger"); data = ""; /* init data */ /* read user input from console with readLine*/ BufferedReader buffread = null; InputStreamReader instrread = null; try { instrread = new InputStreamReader(System.in); buffread = new BufferedReader(instrread); data = buffread.readLine(); } catch (IOException ioe) { log_bad.warning("Error with stream reading"); } finally { /* clean up stream reading objects */ try { if (buffread != null) { buffread.close(); } } catch (IOException ioe) { log_bad.warning("Error closing buffread"); } finally { try { if (instrread != null) { instrread.close(); } } catch (IOException ioe) { log_bad.warning("Error closing instrread"); } } } } /* INCIDENTAL: CWE 571 Statement is Always True */ if (private_final_t) { MessageDigest hash = MessageDigest.getInstance("SHA-512"); hash.update(data.getBytes()); /* FLAW: SHA512 with a predictable salt */ byte[] hashv = hash.digest("hash me".getBytes()); IO.writeLine(IO.toHex(hashv)); } else { /* INCIDENTAL: CWE 561 Dead Code, the code below will never run */ SecureRandom r = new SecureRandom(); MessageDigest hash = MessageDigest.getInstance("SHA-512"); hash.update(r.getSeed(32)); /* FIX: Use a sufficiently random salt */ byte[] hashv = hash.digest("hash me".getBytes()); IO.writeLine(IO.toHex(hashv)); } }
@Override public void send(Quad quad) { try { byte[] s = tdbloader3.serialize(quad.getSubject()).getBytes("UTF-8"); byte[] p = tdbloader3.serialize(quad.getPredicate()).getBytes("UTF-8"); byte[] o = tdbloader3.serialize(quad.getObject()).getBytes("UTF-8"); byte[] g = null; // Union graph?! if (!quad.isTriple() && !quad.isDefaultGraph()) g = tdbloader3.serialize(quad.getGraph()).getBytes("UTF-8"); digest.reset(); digest.update(s); // TODO: should we do something better here? digest.update(p); digest.update(o); if (g != null) digest.update(g.toString().getBytes("UTF-8")); String md5 = new String(Hex.encodeHex(digest.digest())); sdb01.add(new Pair<byte[], byte[]>(s, (md5 + "|s").getBytes("UTF-8"))); sdb01.add(new Pair<byte[], byte[]>(p, (md5 + "|p").getBytes("UTF-8"))); sdb01.add(new Pair<byte[], byte[]>(o, (md5 + "|o").getBytes("UTF-8"))); if (g != null) sdb01.add(new Pair<byte[], byte[]>(g, (md5 + "|g").getBytes("UTF-8"))); } catch (UnsupportedEncodingException e) { throw new AtlasException(e); } monitor.tick(); }
public static String GenerateHash(String url, Request request, boolean getRequest) { int start = HASH_SIZE * request.getAccessIndex(); int end = start + HASH_SIZE; DaapHost host = request.getHost(); calculateStaticHash(host); // System.out.println("Creating hash, reqid is " + reqid); if (host.getDaapVersion() >= DaapHost.ITUNES_45) { // System.out.println("Generating 4.5 Hash"); // nmd = new MD5(); // nmd.Update(url.getBytes()); // nmd.Update(appleCopyright.getBytes()); // nmd.Update(calcHash.substring(start, end).getBytes()); // // if (getRequest) { // nmd.Update((new Integer(host.getThisRequestNumber())).toString().getBytes()); // // System.out.println("Adding this compontent"); // // } // return DigestToString(nmd.Final()); return ""; } else { md.update(url.getBytes()); md.update(appleCopyright.getBytes()); md.update(calcHash.substring(start, end).getBytes()); return DigestToString(md.digest()); } }
static void parseXml(Element p_element, MessageDigest p_md, ArrayList<String> p_ignoreList) { p_md.update(p_element.getName().getBytes()); String content = p_element.getText(); if (content != null) { p_md.update(content.getBytes()); } for (Attribute attribute : p_element.getAttributes()) { String name = attribute.getName(); if (p_ignoreList.contains(name)) { continue; } String value = attribute.getValue(); if (value != null) { p_md.update(value.getBytes()); } } for (Element child : p_element.getChildren()) { parseXml(child, p_md, p_ignoreList); } }
public byte[] hash48(byte[] in, byte[] salt1, byte[] salt2, int salt) throws CryptoException { byte[] shasig = new byte[20]; byte[] pad = new byte[4]; byte[] out = new byte[48]; int i = 0; synchronized (digestLock) { sha1.reset(); md5.reset(); for (i = 0; i < 3; i++) { for (int j = 0; j <= i; j++) { pad[j] = (byte) (salt + i); } sha1.update(pad, 0, i + 1); sha1.update(in, 0, 48); sha1.update(salt1, 0, 32); sha1.update(salt2, 0, 32); shasig = sha1.digest(); sha1.reset(); md5.update(in, 0, 48); md5.update(shasig, 0, 20); System.arraycopy(md5.digest(), 0, out, i * 16, 16); } } return out; }
/** * Calculates the NTLM2 Session Response for the given challenge, using the specified password and * client challenge. * * @param password The user's password. * @param challenge The Type 2 challenge from the server. * @param clientChallenge The random 8-byte client challenge. * @return The NTLM2 Session Response. This is placed in the NTLM response field of the Type 3 * message; the LM response field contains the client challenge, null-padded to 24 bytes. */ static byte[] getNTLM2SessionResponse(String password, byte[] challenge, byte[] clientChallenge) throws NTLMEngineException { try { byte[] ntlmHash = ntlmHash(password); // Look up MD5 algorithm (was necessary on jdk 1.4.2) // This used to be needed, but java 1.5.0_07 includes the MD5 // algorithm (finally) // Class x = Class.forName("gnu.crypto.hash.MD5"); // Method updateMethod = x.getMethod("update",new // Class[]{byte[].class}); // Method digestMethod = x.getMethod("digest",new Class[0]); // Object mdInstance = x.newInstance(); // updateMethod.invoke(mdInstance,new Object[]{challenge}); // updateMethod.invoke(mdInstance,new Object[]{clientChallenge}); // byte[] digest = (byte[])digestMethod.invoke(mdInstance,new // Object[0]); MessageDigest md5 = MessageDigest.getInstance("MD5"); md5.update(challenge); md5.update(clientChallenge); byte[] digest = md5.digest(); byte[] sessionHash = new byte[8]; System.arraycopy(digest, 0, sessionHash, 0, 8); return lmResponse(ntlmHash, sessionHash); } catch (Exception e) { if (e instanceof NTLMEngineException) throw (NTLMEngineException) e; throw new NTLMEngineException(e.getMessage(), e); } }
protected int engineDigest(byte[] buf, int offset, int len) throws DigestException { if (len < HASHSIZE) throw new DigestException(); // hash any remaining fragments blockUpdate(); // composite neighboring nodes together up to top value while (nodes.size() > 1) { List newNodes = new ArrayList(); Iterator iter = nodes.iterator(); while (iter.hasNext()) { byte[] left = (byte[]) iter.next(); if (iter.hasNext()) { byte[] right = (byte[]) iter.next(); tiger.reset(); tiger.update((byte) 1); // node prefix tiger.update(left, 0, left.length); tiger.update(right, 0, right.length); newNodes.add(tiger.digest()); } else { newNodes.add(left); } } nodes = newNodes; } System.arraycopy(nodes.get(0), 0, buf, offset, HASHSIZE); engineReset(); return HASHSIZE; }
/** * 产生MD5加密串 * * @author huyong * @param plainText * @param charset * @return */ private static String to32BitString(String plainText, String charset) { try { MessageDigest md = MessageDigest.getInstance("MD5"); md.reset(); if (charset != null) { md.update(plainText.getBytes(charset)); } else { md.update(plainText.getBytes()); } byte[] byteArray = md.digest(); StringBuffer md5Buf = new StringBuffer(); for (int i = 0; i < byteArray.length; i++) { if (Integer.toHexString(0xFF & byteArray[i]).length() == 1) { md5Buf.append("0").append(Integer.toHexString(0xFF & byteArray[i])); } else { md5Buf.append(Integer.toHexString(0xFF & byteArray[i])); } } return md5Buf.toString(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } return null; }
private static byte[][] evpBytesTokey( int key_len, int iv_len, MessageDigest md, byte[] salt, byte[] data, int count) { byte[][] both = new byte[2][]; byte[] key = new byte[key_len]; int key_ix = 0; byte[] iv = new byte[iv_len]; int iv_ix = 0; both[0] = key; both[1] = iv; byte[] md_buf = null; int nkey = key_len; int niv = iv_len; int i = 0; if (data == null) { return both; } int addmd = 0; for (; ; ) { md.reset(); if (addmd++ > 0) { md.update(md_buf); } md.update(data); if (null != salt) { md.update(salt, 0, 8); } md_buf = md.digest(); for (i = 1; i < count; i++) { md.reset(); md.update(md_buf); md_buf = md.digest(); } i = 0; if (nkey > 0) { for (; ; ) { if (nkey == 0) break; if (i == md_buf.length) break; key[key_ix++] = md_buf[i]; nkey--; i++; } } if (niv > 0 && i != md_buf.length) { for (; ; ) { if (niv == 0) break; if (i == md_buf.length) break; iv[iv_ix++] = md_buf[i]; niv--; i++; } } if (nkey == 0 && niv == 0) { break; } } for (i = 0; i < md_buf.length; i++) { md_buf[i] = 0; } return both; }
private static String sha1Hash(Object[] input) { try { MessageDigest md = MessageDigest.getInstance("SHA-1"); md.reset(); for (Object o : input) { if (o instanceof String) { md.update(((String) o).getBytes("ISO_8859_1")); } else if (o instanceof byte[]) { md.update((byte[]) o); } else { return null; } } BigInteger bigInt = new BigInteger(md.digest()); if (bigInt.compareTo(BigInteger.ZERO) < 0) { bigInt = bigInt.negate(); return "-" + bigInt.toString(16); } else { return bigInt.toString(16); } } catch (Exception ioe) { return null; } }
private static void appendList(MessageDigest digest, List<?> value) { digest.update("L".getBytes()); for (Object object : value) { appendObject(digest, object); digest.update(",".getBytes()); } }
/** * Decodes the passed encrypted password and returns the clear-text form. * * @param encryptedPass encrypted password * @param sharedSecret shared secret * @return decrypted password */ private String decodePapPassword(byte[] encryptedPass, byte[] sharedSecret) throws RadiusException { if (encryptedPass == null || encryptedPass.length < 16) { // PAP passwords require at least 16 bytes logger.warn( "invalid Radius packet: User-Password attribute with malformed PAP password, length = " + (encryptedPass == null ? 0 : encryptedPass.length) + ", but length must be greater than 15"); throw new RadiusException("malformed User-Password attribute"); } MessageDigest md5 = getMd5Digest(); byte[] lastBlock = new byte[16]; for (int i = 0; i < encryptedPass.length; i += 16) { md5.reset(); md5.update(sharedSecret); md5.update(i == 0 ? getAuthenticator() : lastBlock); byte bn[] = md5.digest(); System.arraycopy(encryptedPass, i, lastBlock, 0, 16); // perform the XOR as specified by RFC 2865. for (int j = 0; j < 16; j++) encryptedPass[i + j] = (byte) (bn[j] ^ encryptedPass[i + j]); } // remove trailing zeros int len = encryptedPass.length; while (len > 0 && encryptedPass[len - 1] == 0) len--; byte[] passtrunc = new byte[len]; System.arraycopy(encryptedPass, 0, passtrunc, 0, len); // convert to string return RadiusUtil.getStringFromUtf8(passtrunc); }