/** * Generate a new random password * * @return a new random password */ private String generateRandomPassword( String[] rnd0, String[] rnd1, String[] rnd2, String[] rnd3, String[] rnd4) { StringBuilder ret = new StringBuilder(); // Get lists of random words. We could cache these, but this method is // rarely called and caching would // depend on user locale, so we prefer to waste CPU better than memory. // Get a true random number generator SecureRandom rnd; try { rnd = SecureRandom.getInstance("SHA1PRNG"); } catch (NoSuchAlgorithmException ex) { rnd = new SecureRandom(); } // Generate random numbers int i0 = rnd.nextInt(rnd0.length); int i1 = rnd.nextInt(rnd1.length); int i2 = rnd.nextInt(rnd2.length); int i3 = rnd.nextInt(rnd3.length); int i4 = rnd.nextInt(rnd4.length); // Compose password ret.append(rnd0[i0]); ret.append(rnd1[i1]); ret.append(rnd2[i2]); ret.append(rnd3[i3]); ret.append(rnd4[i4]); return ret.toString(); }
/** * 문자열 A에서 Z사이의 랜덤 문자열을 구하는 기능을 제공 시작문자열과 종료문자열 사이의 랜덤 문자열을 구하는 기능 * * @param startChr - 첫 문자 * @param endChr - 마지막문자 * @return 랜덤문자 * @exception MyException * @see */ public static String getRandomStr(char startChr, char endChr) { int randomInt; String randomStr = null; // 시작문자 및 종료문자를 아스키숫자로 변환한다. int startInt = Integer.valueOf(startChr); int endInt = Integer.valueOf(endChr); // 시작문자열이 종료문자열보가 클경우 if (startInt > endInt) { throw new IllegalArgumentException("Start String: " + startChr + " End String: " + endChr); } try { // 랜덤 객체 생성 SecureRandom rnd = new SecureRandom(); do { // 시작문자 및 종료문자 중에서 랜덤 숫자를 발생시킨다. randomInt = rnd.nextInt(endInt + 1); } while (randomInt < startInt); // 입력받은 문자 'A'(65)보다 작으면 다시 랜덤 숫자 발생. // 랜덤 숫자를 문자로 변환 후 스트링으로 다시 변환 randomStr = (char) randomInt + ""; } catch (Exception e) { e.printStackTrace(); } // 랜덤문자열를 리턴 return randomStr; }
private SecureRandom getSecureRandom(String RNGAlgorithm, String RNGProvider) { try { SecureRandom r; if (RNGProvider != null) { r = SecureRandom.getInstance(RNGAlgorithm, RNGProvider); } else { r = SecureRandom.getInstance(RNGAlgorithm); } r.nextBytes(new byte[1]); return r; } catch (NoSuchProviderException e) { // Fallback to any provider for the algorithm return getSecureRandom(RNGAlgorithm, null); } catch (NoSuchAlgorithmException e) { if (RNGProvider != null) { return getSecureRandom(RNGAlgorithm, null); } Spout.getLogger() .severe( "Unable to find algorithm to generate random number generator for key pair creation (" + RNGAlgorithm + ", " + RNGProvider + ")"); return null; } }
public void putOutMessages() { synchronized (collectedMessages) { int sendable; int pool = collectedMessages.size(); if (pool >= (MIN_POOL + MIN_SEND)) { sendable = pool - MIN_SEND; sendable = Math.min(sendable, Math.max(1, (int) Math.round((double) pool * SEND_RATE))); } else { sendable = 0; } if (sendable > 0) { if (isRequestPool) { for (int i = 0; i < sendable; i++) { int chosen = secureRandom.nextInt(collectedMessages.size()); anonNode.putOutRequest((Request) collectedMessages.remove(chosen)); } } else { for (int i = 0; i < sendable; i++) { int chosen = secureRandom.nextInt(collectedMessages.size()); anonNode.putOutReply((Reply) collectedMessages.remove(chosen)); } } } } }
static { // Generate 8 bytes of random data. SecureRandom secureRandom = new SecureRandom(); byte bytes[] = new byte[8]; secureRandom.nextBytes(bytes); randomBytes = bytes; }
private void rawModeTest( String sigName, ASN1ObjectIdentifier digestOID, PrivateKey privKey, PublicKey pubKey, SecureRandom random) throws Exception { byte[] sampleMessage = new byte[1000 + random.nextInt(100)]; random.nextBytes(sampleMessage); Signature normalSig = Signature.getInstance(sigName, "BC"); normalSig.initSign(privKey); normalSig.update(sampleMessage); byte[] normalResult = normalSig.sign(); MessageDigest digest = MessageDigest.getInstance(digestOID.getId(), "BC"); byte[] hash = digest.digest(sampleMessage); byte[] digInfo = derEncode(digestOID, hash); Signature rawSig = Signature.getInstance("RSA", "BC"); rawSig.initSign(privKey); rawSig.update(digInfo); byte[] rawResult = rawSig.sign(); if (!Arrays.areEqual(normalResult, rawResult)) { fail("raw mode signature differs from normal one"); } rawSig.initVerify(pubKey); rawSig.update(digInfo); if (!rawSig.verify(rawResult)) { fail("raw mode signature verification failed"); } }
/** * Generate a random int value uniformly distributed between <code>lower</code> and <code>upper * </code>, inclusive. This algorithm uses a secure random number generator. * * @param lower the lower bound. * @param upper the upper bound. * @return the random integer. */ public int nextSecureInt(int lower, int upper) { if (lower >= upper) { throw new IllegalArgumentException("lower bound must be < upper bound"); } SecureRandom sec = getSecRan(); return lower + (int) (sec.nextDouble() * (upper - lower + 1)); }
public void testSOEProof() { final StringBuilder sb = new StringBuilder(); final SecureRandom random = new SecureRandom(); sb.append("class SOE_test {\n BigInteger BIG = new BigInteger(\n"); int i; for (i = 0; i < 100000; i++) { sb.append(" \"").append(Math.abs(random.nextInt())).append("\" +\n"); } sb.append(" \"\");\n}"); final PsiJavaFile file = (PsiJavaFile) createLightFile("SOE_test.java", sb.toString()); long t = System.currentTimeMillis(); final StubElement tree = NEW_BUILDER.buildStubTree(file); t = System.currentTimeMillis() - t; assertEquals( "PsiJavaFileStub []\n" + " IMPORT_LIST:PsiImportListStub\n" + " CLASS:PsiClassStub[name=SOE_test fqn=SOE_test]\n" + " MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" + " TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" + " EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" + " IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" + " FIELD:PsiFieldStub[BIG:BigInteger=;INITIALIZER_NOT_STORED;]\n" + " MODIFIER_LIST:PsiModifierListStub[mask=4096]\n", DebugUtil.stubTreeToString(tree)); System.out.println("SOE depth=" + i + ", time=" + t + "ms"); }
private static byte[] generateSalt() throws NoSuchAlgorithmException { SecureRandom random = SecureRandom.getInstance("SHA1PRNG"); byte[] salt = new byte[16]; random.nextBytes(salt); return salt; }
/** * 获得加密后的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); }
/** Generate a local password and save it in the local-password file. */ public void postConstruct() { logger.fine("Generating local password"); SecureRandom random = new SecureRandom(); byte[] pwd = new byte[PASSWORD_BYTES]; random.nextBytes(pwd); password = toHex(pwd); File localPasswordFile = new File(env.getConfigDirPath(), LOCAL_PASSWORD_FILE); PrintWriter w = null; try { if (!localPasswordFile.exists()) { localPasswordFile.createNewFile(); /* * XXX - There's a security hole here. * Between the time the file is created and the permissions * are changed to prevent others from opening it, someone * else could open it and wait for the data to be written. * Java needs the ability to create a file that's readable * only by the owner; coming in JDK 7. */ localPasswordFile.setWritable(false, false); // take from all localPasswordFile.setWritable(true, true); // owner only localPasswordFile.setReadable(false, false); // take from all localPasswordFile.setReadable(true, true); // owner only } w = new PrintWriter(localPasswordFile); w.println(password); } catch (IOException ex) { // ignore errors logger.log(Level.FINE, "Exception writing local password file", ex); } finally { if (w != null) w.close(); } }
private HashMap<Point2D, String> makePointList(String category, List<Report> toolResults) { HashMap<Point2D, String> map = new HashMap<Point2D, String>(); char ch = 'A'; // make a list of all points. Add in a tiny random to prevent exact duplicate coordinates in // map for (Report r : toolResults) { OverallResult or = r.getOverallResults().getResults(category); double x = or.getFalsePositiveRate() * 100 + sr.nextDouble() * .000001; double y = or.getTruePositiveRate() * 100 + sr.nextDouble() * .000001 - 1; // this puts the label just below the point Point2D p = new Point2D.Double(x, y); String label = "" + ch; map.put(p, label); ch++; } Point2D ap = new Point2D.Double( afr * 100 + sr.nextDouble() * .000001, atr * 100 + sr.nextDouble() * .000001 - 1); map.put(ap, "" + ch); dedupify(map); return map; }
public Message startAuthentication(AuthenticationMessage msg) throws AuthenticationException, GeneralSecurityException { if (msg instanceof RequestLoginMessage) { RequestLoginMessage rlm = (RequestLoginMessage) msg; username = rlm.getLogin(); if (!allowRoot && username.equals("root")) { throw new AuthenticationException("Must authenticate as a regular user first."); } // generate challange byte[] passhash = UserManager.v().getPassHash(username); if (passhash == null) { throw new AuthenticationException("User has no password"); } ChallangeMessage cm = new ChallangeMessage(); SecureRandom rand = new SecureRandom(); rand.nextBytes(randNumber); cm.setChallange(randNumber, passhash); state = CL_CHALLANGE_SENT; // send the challange return cm; } else if (msg instanceof ChallangeCheckStatusMessage) { // After authentication is complete the client sends this message // It can be safely ignored. We don't care that the client has // actually authenticated us. return null; } throw new AuthenticationException("State Error"); }
public static String generateOTP(int otpLengthNumber) { String otp = new String(); int otpSample = 0; for (int i = 0; i < otpLengthNumber; i++) { otp = otp + "9"; } otpSample = Integer.parseInt(otp); SecureRandom prng; try { prng = SecureRandom.getInstance("SHA1PRNG"); // Number Generation Algorithm otp = new Integer(prng.nextInt(otpSample)).toString(); otp = (otp.length() < otpLengthNumber) ? padleft(otp, otpLengthNumber, '0') : otp; } catch (NoSuchAlgorithmException e) { } // If generated OTP exists in DB -regenerate OTP again boolean otpExists = false; if (otpExists) { generateOTP(otpLengthNumber); } else { return otp; } return otp; }
/* goodG2B1() - use goodsource and badsink by changing first private_final_t to private_final_f */ private void goodG2B1() throws Throwable { int data; /* INCIDENTAL: CWE 570 Statement is Always False */ if (private_final_f) { /* INCIDENTAL: CWE 561 Dead Code, the code below will never run */ Logger log_bad = Logger.getLogger("local-logger"); SecureRandom r = new SecureRandom(); data = r.nextInt(); } else { java.util.logging.Logger log_good = java.util.logging.Logger.getLogger("local-logger"); /* FIX: Use a hardcoded number that won't cause underflow, overflow, divide by zero, or loss-of-precision issues */ data = 2; } /* INCIDENTAL: CWE 571 Statement is Always True */ if (private_final_t) { /* POTENTIAL FLAW: Zero denominator will cause an issue. An integer division will result in an exception. */ IO.writeLine("bad: 100/" + String.valueOf(data) + " = " + (100 / data) + "\n"); } else { /* INCIDENTAL: CWE 561 Dead Code, the code below will never run */ /* FIX: test for a zero denominator */ if (data != 0) { IO.writeLine("100/" + String.valueOf(data) + " = " + (100 / data) + "\n"); } else { IO.writeLine("This would result in a divide by zero"); } } }
public static void main(String[] args) { SecureRandom random; try { random = SecureRandom.getInstance("SHA1PRNG"); byte[] keyBytes = new byte[16]; random.nextBytes(keyBytes); byte[] ivBytes = new byte[16]; random.nextBytes(ivBytes); KeyIVPair keyIvPair = new KeyIVPair( "8x/xUBgX0Up+3UEo39dSeG277JhVj31+ElHkN5+EC0Q=", "Y2SUiIN6JXTdKNK/ZMDyVtLB7gAM9MCCiyrP1xd3bSQ="); // keyIvPair.setKeyBytes(keyBytes); // keyIvPair.setIvBytes(ivBytes); Gson gson = new GsonBuilder().create(); ConsoleProxyPasswordBasedEncryptor encryptor = new ConsoleProxyPasswordBasedEncryptor(gson.toJson(keyIvPair)); String encrypted = encryptor.encryptText("Hello, world"); System.out.println("Encrypted result: " + encrypted); String decrypted = encryptor.decryptText(encrypted); System.out.println("Decrypted result: " + decrypted); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } }
public void afterPropertiesSet() throws Exception { if (provider == null) { srand = SecureRandom.getInstance(algorithm); } else { srand = SecureRandom.getInstance(algorithm, provider); } }
@Override public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { String param = ""; java.util.Enumeration<String> headers = request.getHeaders("foo"); if (headers.hasMoreElements()) { param = headers.nextElement(); // just grab first element } String bar = doSomething(param); try { java.security.SecureRandom secureRandomGenerator = java.security.SecureRandom.getInstance("SHA1PRNG"); // Get 40 random bytes byte[] randomBytes = new byte[40]; secureRandomGenerator.nextBytes(randomBytes); response.getWriter().println("Random bytes are: " + new String(randomBytes)); } catch (java.security.NoSuchAlgorithmException e) { System.out.println("Problem executing SecureRandom.nextBytes() - TestCase"); throw new ServletException(e); } finally { response .getWriter() .println("Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed"); } } // end doPost
/* 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)); } }
/** * @tests javax.crypto.Cipher#getParameters() * @tests javax.crypto.Cipher#init(int, java.security.Key, java.security.AlgorithmParameters, * java.security.SecureRandom) */ public void test_getParameters() throws Exception { /* * If this test is changed, implement the following: * test_initILjava_security_KeyLjava_security_AlgorithmParametersLjava_security_SecureRandom() */ SecureRandom sr = new SecureRandom(); Cipher cipher = null; byte[] apEncoding = null; byte[] iv = new byte[8]; sr.nextBytes(iv); AlgorithmParameters ap = AlgorithmParameters.getInstance("DESede"); ap.init(iv, "RAW"); apEncoding = ap.getEncoded("ASN.1"); cipher = Cipher.getInstance(algorithm + "/CBC/PKCS5Padding"); cipher.init(Cipher.ENCRYPT_MODE, cipherKey, ap, sr); byte[] cipherParmsEnc = cipher.getParameters().getEncoded("ASN.1"); assertTrue("Parameters differ", Arrays.equals(apEncoding, cipherParmsEnc)); }
/** * Generate a random long value uniformly distributed between <code>lower</code> and <code>upper * </code>, inclusive. This algorithm uses a secure random number generator. * * @param lower the lower bound. * @param upper the upper bound. * @return the random integer. */ public long nextSecureLong(long lower, long upper) { if (lower >= upper) { throw new IllegalArgumentException("lower bound must be < upper bound"); } SecureRandom sec = getSecRan(); return lower + (long) (sec.nextDouble() * (upper - lower + 1)); }
private static byte[] key(final byte[] key) throws Exception { final KeyGenerator gen = KeyGenerator.getInstance(ALGORITHM); final SecureRandom sr = SecureRandom.getInstance("SHA1PRNG"); sr.setSeed(key); gen.init(128, sr); return gen.generateKey().getEncoded(); }
// --------------------------------------------------------------- private byte[] getSalt(int saltSize) throws NoSuchAlgorithmException, NoSuchProviderException { // SecureRandom sr = SecureRandom.getInstance( SECURE_RANDOM_ALGORITHM, // SECURITY_PROVIDER ); SecureRandom sr = new SecureRandom(); sr.setSeed(System.currentTimeMillis()); return sr.generateSeed(saltSize); }
/** * Changes the internal state to a new, fully-random version that should have no relation to the * previous state. May be somewhat slow; you shouldn't need to call this often. */ public void randomize() { byte[] bytes = sec.generateSeed(128); for (int i = sec.nextInt() & 127, c = 0; c < 128; c++, i = i + 1 & 127) { state[i & 15] |= bytes[c] << ((i >> 4) << 3); } choice = sec.nextInt(16); }
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); ByteArrayOutputStream baos = new ByteArrayOutputStream(); Bitmap bm = null; bm.compress(Bitmap.CompressFormat.PNG, 100, baos); // bm is the bitmap object byte[] b = baos.toByteArray(); byte[] keyStart = "this is a key".getBytes(); KeyGenerator kgen; try { kgen = KeyGenerator.getInstance("AES"); SecureRandom sr = SecureRandom.getInstance("SHA1PRNG"); sr.setSeed(keyStart); kgen.init(128, sr); // 192 and 256 bits may not be available SecretKey skey = kgen.generateKey(); byte[] key = skey.getEncoded(); // encrypt byte[] encryptedData = encrypt(key, b); // decrypt byte[] decryptedData = decrypt(key, encryptedData); } catch (NoSuchAlgorithmException e) { // TODO 自動產生的 catch 區塊 e.printStackTrace(); } catch (Exception e) { // TODO 自動產生的 catch 區塊 e.printStackTrace(); } }
/** @return Creates a unique path to an activity in the form of 2010-01-21-09-randombit */ public static String createId() { Calendar c = Calendar.getInstance(); String[] vals = new String[4]; vals[0] = "" + c.get(Calendar.YEAR); vals[1] = StringUtils.leftPad("" + (c.get(Calendar.MONTH) + 1), 2, "0"); vals[2] = StringUtils.leftPad("" + c.get(Calendar.DAY_OF_MONTH), 2, "0"); vals[3] = StringUtils.leftPad("" + c.get(Calendar.HOUR_OF_DAY), 2, "0"); StringBuilder id = new StringBuilder(); for (String v : vals) { id.append(v).append("-"); } byte[] bytes = new byte[20]; String randomHash = ""; try { if (random == null) { random = SecureRandom.getInstance("SHA1PRNG"); } random.nextBytes(bytes); randomHash = Arrays.toString(bytes); randomHash = org.sakaiproject.nakamura.util.StringUtils.sha1Hash(randomHash); } catch (NoSuchAlgorithmException e) { } catch (UnsupportedEncodingException e) { } id.append(randomHash); return id.toString(); }
private static byte[] randomBytes(int length) throws GeneralSecurityException { fixPrng(); SecureRandom random = SecureRandom.getInstance(RANDOM_ALGORITHM); byte[] b = new byte[length]; random.nextBytes(b); return b; }
/** * Generate a UUID using <a href="http://www.ietf.org/rfc/rfc4122.txt">RFC 4122</a> UUID * generation of a type 4 or randomly generated UUID. * * @return the 32 character long UUID string. * @throws KeyManagerException */ protected String generateUUID() throws KeyManagerException { byte vfour[] = new byte[KEY_LENGTH]; if (isRandomMode() == SECURE) { if (secureRandom == null) { try { secureRandom = SecureRandom.getInstance("SHA1PRNG"); } catch (NoSuchAlgorithmException e) { setRandomMode(!SECURE); log.warn("Unable to use SecureRandom", e); } } if (isRandomMode() == SECURE) { secureRandom.nextBytes(vfour); } } if (isRandomMode() != SECURE) { if (random == null) { random = new Random(); } random.nextBytes(vfour); } vfour[6] &= 0x0F; vfour[6] |= (4 << 4); vfour[8] &= 0x3F; vfour[8] |= 0x80; return Hex.encode(vfour); }
/** * This method: Encrypts bytes using a cipher. Generates MAC for intialization vector of the * cipher Generates MAC for encrypted data Returns a byte array consisting of the following * concatenated together: |MAC for cnrypted Data | MAC for Init Vector | Encrypted Data | * * @param bytes The byte array to be encrypted. * @return the encrypted byte array. */ public byte[] encrypt(byte[] bytes) { byte[] securedata = null; try { // Generate IV SecureRandom rand = new SecureRandom(); byte[] iv = new byte[16]; rand.nextBytes(iv); IvParameterSpec ivspec = new IvParameterSpec(iv); Cipher encryptCipher = Cipher.getInstance(CIPHER_CODE); encryptCipher.init(Cipher.ENCRYPT_MODE, sk, ivspec); Mac encryptMac = Mac.getInstance(MAC_CODE); encryptMac.init(sk); encryptMac.update(iv); // encrypt the plaintext byte[] encdata = encryptCipher.doFinal(bytes); byte[] macBytes = encryptMac.doFinal(encdata); byte[] tmp = concatBytes(macBytes, iv); securedata = concatBytes(tmp, encdata); } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | InvalidAlgorithmParameterException | IllegalStateException | IllegalBlockSizeException | BadPaddingException e) { if (LOGGER.isLoggable(Level.SEVERE)) { LOGGER.log( Level.SEVERE, "Unexpected exception initializing encryption." + " No encryption will be performed.", e); } return null; } return securedata; }
public Id generateId() throws Exception { MessageDigest md = MessageDigest.getInstance(ds().network.getProperty("hash", "SHA-1")); SecureRandom random = SecureRandom.getInstance("SHA1PRNG"); byte[] input = new byte[200]; random.nextBytes(input); return new Id(md.digest(input)); }