Exemplo n.º 1
0
        //~ func TestHashString(t *testing.T) {
        public void TestHashString()
        {
            //~ inmemStorage := &logical.InmemStorage{}
            //~ inmemStorage.Put(&logical.StorageEntry{
            //~     Key:   "salt",
            //~     Value: []byte("foo"),
            //~ })
            var inmemStorage = new Logical.InmemStorage();

            inmemStorage.Put(new Logical.StorageEntry
            {
                Key   = "salt",
                Value = "foo".ToUtf8Bytes(),
            });
            //~ localSalt, err := salt.NewSalt(inmemStorage, &salt.Config{
            //~     HMAC:     sha256.New,
            //~     HMACType: "hmac-sha256",
            //~ })
            var localSalt = Salt.NewSalt(inmemStorage, new Config
            {
                HMAC     = () => new HMACSHA256(),
                HMACType = "hmac-sha256",
            });
            //~ if err != nil {
            //~     t.Fatalf("Error instantiating salt: %s", err)
            //~ }
            //~ out := HashString(localSalt, "foo")
            //~ if out != "hmac-sha256:08ba357e274f528065766c770a639abf6809b39ccfd37c2a3157c7f51954da0a" {
            //~     t.Fatalf("err: HashString output did not match expected")
            //~ }
            var @out = HashStructure.HashString(localSalt, "foo");

            Assert.AreEqual("hmac-sha256:08ba357e274f528065766c770a639abf6809b39ccfd37c2a3157c7f51954da0a", @out.ToLower());
        }
Exemplo n.º 2
0
        //~ func TestSalt(t *testing.T) {
        public void TestSalt()
        {
            //~ inm := &logical.InmemStorage{}
            //~ conf := &Config{}
            var inm  = new Logical.InmemStorage();
            var conf = new Config();

            //~ salt, err := NewSalt(inm, conf)
            //~ if err != nil {
            //~     t.Fatalf("err: %v", err)
            //~ }
            var salt = Salt.NewSalt(inm, conf);

            //~ if !salt.DidGenerate() {
            //~     t.Fatalf("expected generation")
            //~ }
            Assert.IsTrue(salt.DidGenerate());

            // Verify the salt exists
            //~ out, err := inm.Get(DefaultLocation)
            //~ if err != nil {
            //~     t.Fatalf("err: %v", err)
            //~ }
            //~ if out == nil {
            //~     t.Fatalf("missing salt")
            //~ }
            var @out = inm.Get(Salt.DefaultLocation);

            Assert.IsNotNull(@out);

            // Create a new salt, should restore
            //~ salt2, err := NewSalt(inm, conf)
            //~ if err != nil {
            //~     t.Fatalf("err: %v", err)
            //~ }
            var salt2 = Salt.NewSalt(inm, conf);

            //~ if salt2.DidGenerate() {
            //~     t.Fatalf("unexpected generation")
            //~ }
            Assert.IsFalse(salt2.DidGenerate());

            // Check for a match
            //~ if salt.salt != salt2.salt {
            //~     t.Fatalf("salt mismatch: %s %s", salt.salt, salt2.salt)
            //~ }
            Assert.AreEqual(salt.SaltValue, salt.SaltValue);

            // Verify a match
            //~ id := "foobarbaz"
            //~ sid1 := salt.SaltID(id)
            //~ sid2 := salt2.SaltID(id)
            //~
            //~ if sid1 != sid2 {
            //~     t.Fatalf("mismatch")
            //~ }
            var id   = "foobarbaz";
            var sid1 = salt.SaltID(id);
            var sid2 = salt2.SaltID(id);

            Assert.AreEqual(sid1, sid2);
        }