193 lines
4.5 KiB
C++
193 lines
4.5 KiB
C++
/*============================================================================
|
|
CMake - Cross Platform Makefile Generator
|
|
Copyright 2014 Kitware, Inc., Insight Software Consortium
|
|
|
|
Distributed under the OSI-approved BSD License (the "License");
|
|
see accompanying file Copyright.txt for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even the
|
|
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
See the License for more information.
|
|
============================================================================*/
|
|
#include "cmUuid.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include "cm_sha2.h"
|
|
#include <cmsys/MD5.h>
|
|
|
|
cmUuid::cmUuid()
|
|
{
|
|
Groups.push_back(4);
|
|
Groups.push_back(2);
|
|
Groups.push_back(2);
|
|
Groups.push_back(2);
|
|
Groups.push_back(6);
|
|
}
|
|
|
|
std::string cmUuid::FromMd5(std::vector<unsigned char> const& uuidNamespace,
|
|
std::string const& name) const
|
|
{
|
|
std::vector<unsigned char> hashInput;
|
|
this->CreateHashInput(uuidNamespace, name, hashInput);
|
|
|
|
cmsysMD5_s* md5 = cmsysMD5_New();
|
|
cmsysMD5_Initialize(md5);
|
|
cmsysMD5_Append(md5, &hashInput[0], int(hashInput.size()));
|
|
|
|
unsigned char digest[16] = { 0 };
|
|
cmsysMD5_Finalize(md5, digest);
|
|
|
|
cmsysMD5_Delete(md5);
|
|
|
|
return this->FromDigest(digest, 3);
|
|
}
|
|
|
|
std::string cmUuid::FromSha1(std::vector<unsigned char> const& uuidNamespace,
|
|
std::string const& name) const
|
|
{
|
|
std::vector<unsigned char> hashInput;
|
|
this->CreateHashInput(uuidNamespace, name, hashInput);
|
|
|
|
SHA_CTX* sha = new SHA_CTX;
|
|
SHA1_Init(sha);
|
|
SHA1_Update(sha, &hashInput[0], hashInput.size());
|
|
|
|
unsigned char digest[SHA1_DIGEST_LENGTH] = { 0 };
|
|
SHA1_Final(digest, sha);
|
|
|
|
delete sha;
|
|
|
|
return this->FromDigest(digest, 5);
|
|
}
|
|
|
|
void cmUuid::CreateHashInput(std::vector<unsigned char> const& uuidNamespace,
|
|
std::string const& name,
|
|
std::vector<unsigned char>& output) const
|
|
{
|
|
output = uuidNamespace;
|
|
|
|
if (!name.empty()) {
|
|
output.resize(output.size() + name.size());
|
|
|
|
memcpy(&output[0] + uuidNamespace.size(), name.c_str(), name.size());
|
|
}
|
|
}
|
|
|
|
std::string cmUuid::FromDigest(const unsigned char* digest,
|
|
unsigned char version) const
|
|
{
|
|
typedef unsigned char byte_t;
|
|
|
|
byte_t uuid[16] = { 0 };
|
|
memcpy(uuid, digest, 16);
|
|
|
|
uuid[6] &= 0xF;
|
|
uuid[6] |= byte_t(version << 4);
|
|
|
|
uuid[8] &= 0x3F;
|
|
uuid[8] |= 0x80;
|
|
|
|
return this->BinaryToString(uuid);
|
|
}
|
|
|
|
bool cmUuid::StringToBinary(std::string const& input,
|
|
std::vector<unsigned char>& output) const
|
|
{
|
|
output.clear();
|
|
output.reserve(16);
|
|
|
|
if (input.length() != 36) {
|
|
return false;
|
|
}
|
|
size_t index = 0;
|
|
for (size_t i = 0; i < this->Groups.size(); ++i) {
|
|
if (i != 0 && input[index++] != '-') {
|
|
return false;
|
|
}
|
|
size_t digits = this->Groups[i] * 2;
|
|
if (!StringToBinaryImpl(input.substr(index, digits), output)) {
|
|
return false;
|
|
}
|
|
|
|
index += digits;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
std::string cmUuid::BinaryToString(const unsigned char* input) const
|
|
{
|
|
std::string output;
|
|
|
|
size_t inputIndex = 0;
|
|
for (size_t i = 0; i < this->Groups.size(); ++i) {
|
|
if (i != 0) {
|
|
output += '-';
|
|
}
|
|
|
|
size_t bytes = this->Groups[i];
|
|
for (size_t j = 0; j < bytes; ++j) {
|
|
unsigned char byte = input[inputIndex++];
|
|
output += this->ByteToHex(byte);
|
|
}
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
std::string cmUuid::ByteToHex(unsigned char byte) const
|
|
{
|
|
std::string result;
|
|
for (int i = 0; i < 2; ++i) {
|
|
unsigned char rest = byte % 16;
|
|
byte /= 16;
|
|
|
|
char c = (rest < 0xA) ? char('0' + rest) : char('a' + (rest - 0xA));
|
|
|
|
result = c + result;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool cmUuid::StringToBinaryImpl(std::string const& input,
|
|
std::vector<unsigned char>& output) const
|
|
{
|
|
if (input.size() % 2) {
|
|
return false;
|
|
}
|
|
|
|
for (size_t i = 0; i < input.size(); i += 2) {
|
|
char c1 = 0;
|
|
if (!IntFromHexDigit(input[i], c1)) {
|
|
return false;
|
|
}
|
|
|
|
char c2 = 0;
|
|
if (!IntFromHexDigit(input[i + 1], c2)) {
|
|
return false;
|
|
}
|
|
|
|
output.push_back(char(c1 << 4 | c2));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cmUuid::IntFromHexDigit(char input, char& output) const
|
|
{
|
|
if (input >= '0' && input <= '9') {
|
|
output = char(input - '0');
|
|
return true;
|
|
} else if (input >= 'a' && input <= 'f') {
|
|
output = char(input - 'a' + 0xA);
|
|
return true;
|
|
} else if (input >= 'A' && input <= 'F') {
|
|
output = char(input - 'A' + 0xA);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|