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;
}
