GEEKING

App/util/ProtectedString.cpp

@@ -0,0 +1,198 @@
+#include "stdafx.h"
+
+#include "Util/ProtectedString.h"
+
+#include "Reflection/Property.h"
+#include "Util/MD5Hasher.h"
+#include "V8DataModel/HackDefines.h"
+
+#include <string>
+
+namespace RBX {
+
+const ProtectedString ProtectedString::emptyString;
+
+ProtectedString::ProtectedString() : hash(new std::string())
+{
+	// Call setString here so that the no-arg constructor is guaranteed to act
+	// the same as setting the string to empty.
+	setString("", "");
+}
+
+ProtectedString::ProtectedString(const ProtectedString& other)
+    : source(other.source)
+    , bytecode(other.bytecode)
+    , hash(new std::string(*other.hash))
+{
+	// Don't use setString here, preserve all of the fields from other 
+	// precisely as they are. If the source hasn't been tampered with
+	// then the hash will match, otherwise we want to preserve the fact that
+	// the hash is invalid for source.
+}
+
+ProtectedString ProtectedString::fromTrustedSource(const std::string& trustedString)
+{
+	ProtectedString result;
+	result.setString(trustedString, "");
+	return result;
+}
+
+ProtectedString ProtectedString::fromBytecode(const std::string& stringRef)
+{
+	ProtectedString result;
+	result.setString("", stringRef);
+	return result;
+}
+
+void ProtectedString::setString(const std::string& newSource, const std::string& newBytecode)
+{
+	source = newSource;
+    bytecode = newBytecode;
+	calculateHash(hash.get());
+#if !defined(RBX_STUDIO_BUILD)
+	if (source != newSource)
+	{
+		DataModel::sendStats |= HATE_LUA_SCRIPT_HASH_CHANGED;
+	}
+#endif
+}
+
+const std::string& ProtectedString::getOriginalHash() const
+{
+	return *hash;
+}
+
+void ProtectedString::calculateHash(std::string* out) const
+{
+	if (!source.empty()) {
+		boost::scoped_ptr<MD5Hasher> hasher(MD5Hasher::create());
+		// adding salt to hash computation
+        // by using the __TIME__ macro we essentially randomize the salt between builds
+		hasher->addData(__TIME__);
+		hasher->addData(source);
+		*out = hasher->toString();
+	} else {
+		*out = std::string();
+	}
+}
+
+bool ProtectedString::operator==(const ProtectedString& other) const
+{
+	return source == other.source && bytecode == other.bytecode;
+}
+
+bool ProtectedString::operator!=(const ProtectedString& other) const
+{
+    return !(*this == other);
+}
+
+ProtectedString& ProtectedString::operator=(const ProtectedString& other)
+{
+	setString(other.source, other.bytecode);
+	return *this;
+}
+
+size_t hash_value(const ProtectedString& value)
+{
+    size_t seed = 0;
+    boost::hash_combine(seed, value.getSource());
+    boost::hash_combine(seed, value.getBytecode());
+    return seed;
+}
+    
+}
+
+template<>
+bool XmlNameValuePair::getValue(RBX::ProtectedString& value) const {
+	std::string tmp;
+	if (getValue(tmp)) {
+		value = RBX::ProtectedString::fromTrustedSource(tmp);
+		return true;
+	}
+	return false;
+}
+
+namespace RBX
+{
+	template<>
+	std::string StringConverter<ProtectedString>::convertToString(const ProtectedString& value)
+	{
+		return value.getSource();
+	}
+
+	template<>
+	bool StringConverter<ProtectedString>::convertToValue(const std::string& text, ProtectedString& value)
+	{
+		value = ProtectedString::fromTrustedSource(text);
+		return true;
+	}
+
+	namespace Reflection
+	{		
+		template<>
+		const Type& Type::getSingleton<ProtectedString>()
+		{
+			static TType<RBX::ProtectedString> type("ProtectedString");
+			return type;
+		}
+
+
+		template<>
+		void TypedPropertyDescriptor<ProtectedString>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
+		{
+			if (!element->isXsiNil())
+			{
+				ProtectedString value;
+				if (element->getValue(value))
+					setValue(instance, value);
+			}
+		}
+
+		template<>
+		void TypedPropertyDescriptor<ProtectedString>::writeValue(const DescribedBase* instance, XmlElement* element) const
+		{
+			element->setValue(StringConverter<ProtectedString>::convertToString(getValue(instance)));
+		}
+
+
+
+		template<>
+		ProtectedString& Variant::convert<ProtectedString>(void)
+		{
+			if (_type->isType<std::string>())
+			{
+				value = cast<std::string>();
+				_type = &Type::singleton<ProtectedString>();
+			}
+			return genericConvert<ProtectedString>();
+		}
+
+        template<>
+        int TypedPropertyDescriptor<ProtectedString>::getDataSize(const DescribedBase* instance) const 
+        {
+            return sizeof(ProtectedString) + getValue(instance).getSource().length();
+        }
+
+		template<>
+		bool TypedPropertyDescriptor<ProtectedString>::hasStringValue() const {
+			return true;
+		}
+
+		template<>
+		std::string TypedPropertyDescriptor<ProtectedString>::getStringValue(const DescribedBase* instance) const{
+			return StringConverter<ProtectedString>::convertToString(getValue(instance));
+		}
+
+		template<>
+		bool TypedPropertyDescriptor<ProtectedString>::setStringValue(DescribedBase* instance, const std::string& text) const {
+			ProtectedString value;
+			if (StringConverter<ProtectedString>::convertToValue(text, value))
+			{
+				setValue(instance, value);
+				return true;
+			}
+			else
+				return false;
+		}
+	}
+}