Homeland Security wants less Encryption

The full text of the speech given by the Remarks by Secretary of Homeland Security Jeh Johnson at the RSA Conference 2015 can be found here. I think it is very telling where Homeland Security is from this small except:

"Now, finally, I have an ask: for your indulgence and your understanding on the subject of encryption. 

The Department of Homeland Security has both the cybersecurity mission and a law enforcement/counterterrorism mission for the American people. We have feet in both camps. I therefore believe I have a good perspective on this issue. 

The current course we are on, toward deeper and deeper encryption in response to the demands of the marketplace, is one that presents real challenges for those in law enforcement and national security.

Let me be clear: I understand the importance of what encryption brings to privacy. But, imagine the problems if, well after the advent of the telephone, the warrant authority of the government to investigate crime had extended only to the U.S. mail.

Our inability to access encrypted information poses public safety challenges. 

In fact, encryption is making it harder for your government to find criminal activity, and potential terrorist activity. 

We in government know that a solution to this dilemma must take full account of the privacy rights and expectations of the American public, the state of the technology, and the cybersecurity of American businesses."

First of all, uh, no. Second, are you kidding? The government has mountains of information in the form of metadata that they need absolutly no warrant for. They want back doors which make the encryption pointless. Maybe it's time some smart Silicon Valley engineers work for them rather than just VPs and Execs getting cushy jobs. Just sayin'. If other industries can do it like Monsonto with the FDA why not us?

Properties in C++ Part II

Last week I posed about making properties in C++. That code sample had some issues that I fine tuned with the code sample in this post. Here is the new class(s).

template <typename ObjectType, typename ValueType, ValueType (ObjectType::*getter)(void), void (ObjectType::*setter)(ValueType)>

class Property {

private:

    ObjectType* FObject;

    

public:

    Property() {

        FObject = NULL;

    }

    

    void SetInstance(ObjectType* Value) {

        FObject = Value;

    }

    

    // To set the value using the set method.

    ValueType operator =(const ValueType& Value) {

        assert(FObject != NULL);

        (FObject->*setter)(Value);

        return Value;

    }

    

    // The Property class is treated as the internal type.

    operator ValueType() {

        assert(FObject != NULL);

        return (FObject->*getter)();

    }

};

template <typename ObjectType, typename ValueType, ValueType (ObjectType::*getter)(void)>

class ReadProperty {

private:

    ObjectType* FObject;

    

public:

    ReadProperty() {

        FObject = NULL;

    }

    

    void SetInstance(ObjectType* Value) {

        FObject = Value;

    }

    

    // The Property class is treated as the internal type.

    operator ValueType() {

        assert(FObject != NULL);

        return (FObject->*getter)();

    }

};

template <typename ObjectType, typename ValueType, void (ObjectType::*setter)(ValueType)>

class WriteProperty {

private:

    ObjectType* FObject;

    

public:

    WriteProperty() {

        FObject = NULL;

    }

    

    void SetInstance(ObjectType* Value) {

        FObject = Value;

    }

    

    // To set the value using the set method.

    ValueType operator =(const ValueType& Value) {

        assert(FObject != NULL);

        (FObject->*setter)(Value);

        return Value;

    }

};

template <typename ObjectType, typename ValueType, ValueType (ObjectType::getter)(void), void (ObjectType::setter)(ValueType)>

class StaticProperty {

private:

    

public:

    StaticProperty() {

    }

    

    // To set the value using the set method.

    ValueType operator =(const ValueType& Value) {

        (*setter)(Value);

        return Value;

    }

    

    // The Property class is treated as the internal type which is the getter.

    operator ValueType() {

        return (*getter)();

    }

};

template <typename ObjectType, typename ValueType, ValueType (ObjectType::getter)(void)>

class StaticReadProperty {

private:

    

public:

    StaticReadProperty() {

    }

    

    // The Property class is treated as the internal type which is the getter.

    operator ValueType() {

        return (*getter)();

    }

};

template <typename ObjectType, typename ValueType, void (ObjectType::setter)(ValueType)>

class StaticWriteProperty {

private:

    

public:

    StaticWriteProperty() {

    }

    

    // To set the value using the set method.

    ValueType operator =(const ValueType& Value) {

        (*setter)(Value);

        return Value;

    }

};

As you can see there are several classes. I moved the read/write/readwrite enum from being a field of the property class to being a class. I also added static versions. Oh, why would one want a static property? Well, here are a couple examples of using these:

class Environment {

public:

    Environment() {

        PropertyTest.SetInstance(this);

    }

    

// Property

private:

    std::string FPropertyTest;

    

public:

    void SetPropertyTest(std::string Value) { FPropertyTest = Value; }

    std::string GetPropertyTest() { return FPropertyTest; }

    

    Property<Environment, std::string, &Environment::GetPropertyTest, &Environment::SetPropertyTest> PropertyTest;

// Static Property

private:

    static std::string FTest;

public:

    static void SetTest(std::string Value) { FTest = Value; }

    static std::string GetTest() { return FTest; }

    

    static StaticProperty<Environment, std::string, &Environment::GetTest, &Environment::SetTest> Test;

};

StaticProperty<Environment, std::string, &Environment::GetTest, &Environment::SetTest> Environment::Test;

std::string Environment::FTest = "foo";

There are a few limitations still. For example, the dot (.) operator cannot be overridden. So doing:

printf("%s\n", Environment::Test.data());

isn't going to work. The arrow (->) operator can be overridden, so this behavior could be supported that way if one was so inclined. Seems a little odd. I could go either way.

Properties in C++

A long time ago when I was working on Borland C++ and Delphi was just a baby, we added properties as a language extension to C++. Nobody at the C++ committee liked the notion (not sure why, but Java didn't like it either), but I came up with a way of doing properties in C++ using templates. Here is the property class:

enum PropertyType {READ_ONLY, WRITE_ONLY, READ_WRITE};

template <typename Container, typename ValueType, PropertyType Type>

class Property {

private:

    Container* FObject;

    void (Container::*FSetter)(ValueType value);

    ValueType (Container::*FGetter)();

    

public:

    Property() {

        FObject = NULL;

        FSetter = NULL;

        FGetter = NULL;

    }

    

    void InitializeSetterGetter(Container* Value,

                                void (Container::*Setter)(ValueType Value),

                                ValueType (Container::*Getter)()) {

        assert(Type == READ_WRITE);

        FObject = Value;

        FSetter = Setter;

        FGetter = Getter;

    }

    void InitializeSetter(Container* Value,

                          void (Container::*Setter)(ValueType Value)) {

        assert(Type == WRITE_ONLY);

        FObject = Value;

        FSetter = Setter;

    }

    void InitializeGetter(Container* Value,

                          ValueType (Container::*Getter)()) {

        assert(Type == READ_ONLY);

        FObject = Value;

        FGetter = Getter;

    }

    

    // To set the value using the set method.

    ValueType operator =(const ValueType& Value) {

        assert(FObject != NULL);

        assert(FSetter != NULL);

        (FObject->*FSetter)(Value);

        return Value;

    }

    

    // The Property class is treated as the internal type.

    operator ValueType() {

        assert(FObject != NULL);

        assert(FGetter != NULL);

        return (FObject->*FGetter)();

    }

};

Now, to use this, call one of the Initializer* functions from within your classes constructor, provide getter and setter methods and instantiate the property as follows:

class TestProperty {

protected:

    std::string FMyProperty;

    

public:

    TestProperty() {

        MyProperty.InitializeGetter(this,

                                    &TestProperty::SetMyProperty

                                    &TestProperty::GetMyProperty);

    }

    std::string GetMyProperty() {

        return FMyProperty;

    }

    void SetMyProperty(std::string Value) {

        FMyProperty = Value

    }

    

    Property<Process, std::string, READ_WRITE> MyProperty;

};

It's a bit more work than if you were to use a language that supports properties such as Delphi or C#, but it can be a very handy syntactic sugar.