static String generateSecWebSocketKey() { static const size_t nonceSize = 16; unsigned char key[nonceSize]; cryptographicallyRandomValues(key, nonceSize); return base64Encode(reinterpret_cast<char*>(key), nonceSize); }
uint64_t PluginProcessManager::pluginProcessToken(const PluginModuleInfo& pluginModuleInfo, PluginProcessType pluginProcessType, PluginProcessSandboxPolicy pluginProcessSandboxPolicy) { // See if we know this token already. for (size_t i = 0; i < m_pluginProcessTokens.size(); ++i) { const PluginProcessAttributes& attributes = m_pluginProcessTokens[i].first; if (attributes.moduleInfo.path == pluginModuleInfo.path && attributes.processType == pluginProcessType && attributes.sandboxPolicy == pluginProcessSandboxPolicy) return m_pluginProcessTokens[i].second; } uint64_t token; while (true) { cryptographicallyRandomValues(&token, sizeof(token)); if (m_knownTokens.isValidValue(token) && !m_knownTokens.contains(token)) break; } PluginProcessAttributes attributes; attributes.moduleInfo = pluginModuleInfo; attributes.processType = pluginProcessType; attributes.sandboxPolicy = pluginProcessSandboxPolicy; m_pluginProcessTokens.append(std::make_pair(WTF::move(attributes), token)); m_knownTokens.add(token); return token; }
// Note: This implementation must be thread-safe, as it is used by workers. void Crypto::getRandomValues(ArrayBufferView* array, ExceptionState& es) { if (!array || !isIntegerArray(array)) { es.throwUninformativeAndGenericDOMException(TypeMismatchError); return; } if (array->byteLength() > 65536) { es.throwUninformativeAndGenericDOMException(QuotaExceededError); return; } cryptographicallyRandomValues(array->baseAddress(), array->byteLength()); }
void Crypto::getRandomValues(ArrayBufferView* array, ExceptionCode& ec) { if (!array || !isIntegerArray(array)) { ec = TYPE_MISMATCH_ERR; return; } if (array->byteLength() > 65536) { ec = QUOTA_EXCEEDED_ERR; return; } cryptographicallyRandomValues(array->baseAddress(), array->byteLength()); }
void Crypto::getRandomValues(ArrayBufferView* array, ExceptionCode& ec) { #if USE(OS_RANDOMNESS) if (!array || !isIntegerArray(array)) { ec = TYPE_MISMATCH_ERR; return; } cryptographicallyRandomValues(array->baseAddress(), array->byteLength()); #else ASSERT_UNUSED(array, array); ec = NOT_SUPPORTED_ERR; #endif }
DOMArrayBufferView* Crypto::getRandomValues(DOMArrayBufferView* array, ExceptionState& exceptionState) { ASSERT(array); if (!isIntegerArray(array)) { exceptionState.throwDOMException(TypeMismatchError, String::format("The provided ArrayBufferView is of type '%s', which is not an integer array type.", array->typeName())); return nullptr; } if (array->byteLength() > 65536) { exceptionState.throwDOMException(QuotaExceededError, String::format("The ArrayBufferView's byte length (%u) exceeds the number of bytes of entropy available via this API (65536).", array->byteLength())); return nullptr; } cryptographicallyRandomValues(array->baseAddress(), array->byteLength()); return array; }
static String generateRandomBoundary() { // Trying to generate random boundaries similar to IE/UnMHT (ex: ----=_NextPart_000_001B_01CC157B.96F808A0). const size_t randomValuesLength = 10; char randomValues[randomValuesLength]; cryptographicallyRandomValues(&randomValues, randomValuesLength); StringBuilder stringBuilder; stringBuilder.append("----=_NextPart_000_"); for (size_t i = 0; i < randomValuesLength; ++i) { if (i == 2) stringBuilder.append('_'); else if (i == 6) stringBuilder.append('.'); stringBuilder.append(lowerNibbleToASCIIHexDigit(randomValues[i])); stringBuilder.append(upperNibbleToASCIIHexDigit(randomValues[i])); } return stringBuilder.toString(); }
String createCanonicalUUIDString() { unsigned randomData[4]; cryptographicallyRandomValues(reinterpret_cast<unsigned char*>(randomData), sizeof(randomData)); // Format as Version 4 UUID. StringBuilder builder; builder.reserveCapacity(36); appendUnsignedAsHexFixedSize(randomData[0], builder, 8, Lowercase); builder.append("-"); appendUnsignedAsHexFixedSize(randomData[1] >> 16, builder, 4, Lowercase); builder.append("-4"); appendUnsignedAsHexFixedSize(randomData[1] & 0x00000fff, builder, 3, Lowercase); builder.append("-"); appendUnsignedAsHexFixedSize((randomData[2] >> 30) | 0x8, builder, 1, Lowercase); appendUnsignedAsHexFixedSize((randomData[2] >> 16) & 0x00000fff, builder, 3, Lowercase); builder.append("-"); appendUnsignedAsHexFixedSize(randomData[2] & 0x0000ffff, builder, 4, Lowercase); appendUnsignedAsHexFixedSize(randomData[3], builder, 8, Lowercase); return builder.toString(); }
String openTemporaryFile(const String&, PlatformFileHandle& handle) { handle = INVALID_HANDLE_VALUE; wchar_t tempPath[MAX_PATH]; int tempPathLength = ::GetTempPathW(WTF_ARRAY_LENGTH(tempPath), tempPath); if (tempPathLength <= 0 || tempPathLength > WTF_ARRAY_LENGTH(tempPath)) return String(); String proposedPath; do { wchar_t tempFile[] = L"XXXXXXXX.tmp"; // Use 8.3 style name (more characters aren't helpful due to 8.3 short file names) const int randomPartLength = 8; cryptographicallyRandomValues(tempFile, randomPartLength * sizeof(wchar_t)); // Limit to valid filesystem characters, also excluding others that could be problematic, like punctuation. // don't include both upper and lowercase since Windows file systems are typically not case sensitive. const char validChars[] = "0123456789abcdefghijklmnopqrstuvwxyz"; for (int i = 0; i < randomPartLength; ++i) tempFile[i] = validChars[tempFile[i] % (sizeof(validChars) - 1)]; ASSERT(wcslen(tempFile) == WTF_ARRAY_LENGTH(tempFile) - 1); proposedPath = pathByAppendingComponent(tempPath, tempFile); if (proposedPath.isEmpty()) break; // use CREATE_NEW to avoid overwriting an existing file with the same name handle = ::CreateFileW(proposedPath.charactersWithNullTermination().data(), GENERIC_READ | GENERIC_WRITE, 0, 0, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0); } while (!isHandleValid(handle) && GetLastError() == ERROR_ALREADY_EXISTS); if (!isHandleValid(handle)) return String(); return proposedPath; }
static void generateKey3(unsigned char key3[8]) { cryptographicallyRandomValues(key3, 8); }
uint32_t cryptographicallyRandomNumber() { uint32_t result; cryptographicallyRandomValues(&result, sizeof(result)); return result; }
Vector<uint8_t> CryptoKey::randomData(size_t size) { Vector<uint8_t> result(size); cryptographicallyRandomValues(result.data(), result.size()); return result; }