//~ func TestSaltID(t *testing.T) {
public void TestSaltID()
{
//~ salt, err := uuid.GenerateUUID()
//~ if err != nil {
//~ t.Fatal(err)
//~ }
//~ id := "foobarbaz"
var salt = Guid.NewGuid().ToString();
var id = "foobarbaz";
//~ sid1 := SaltID(salt, id, SHA1Hash)
//~ sid2 := SaltID(salt, id, SHA1Hash)
var sid1 = Salt.SaltID(salt, id, Salt.SHA1Hash);
var sid2 = Salt.SaltID(salt, id, Salt.SHA1Hash);
//~ if len(sid1) != sha1.Size*2 {
//~ t.Fatalf("Bad len: %d %s", len(sid1), sid1)
//~ }
Assert.AreEqual(SHA1.Create().HashSize / 8 * 2, sid1.Length);
//~ if sid1 != sid2 {
//~ t.Fatalf("mismatch")
//~ }
Assert.AreEqual(sid1, sid2);
//~ sid1 = SaltID(salt, id, SHA256Hash)
//~ sid2 = SaltID(salt, id, SHA256Hash)
sid1 = Salt.SaltID(salt, id, Salt.SHA256Hash);
sid2 = Salt.SaltID(salt, id, Salt.SHA256Hash);
//~if len(sid1) != sha256.Size*2 {
//~ t.Fatalf("Bad len: %d", len(sid1))
//~}
Assert.AreEqual(SHA256.Create().HashSize / 8 * 2, sid1.Length);
//~if sid1 != sid2 {
//~ t.Fatalf("mismatch")
//~}
Assert.AreEqual(sid1, sid2);
}
//~ 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);
}
// NewSalt creates a new salt based on the configuration
//~ func NewSalt(view logical.Storage, config *Config) (*Salt, error) {
public static Salt NewSalt(Logical.IStorage view, Config config)
{
// Setup the configuration
//~ if config == nil {
//~ config = &Config{}
//~ }
//~ if config.Location == "" {
//~ config.Location = DefaultLocation
//~ }
//~ if config.HashFunc == nil {
//~ config.HashFunc = SHA256Hash
//~ }
//~ if config.HMAC == nil {
//~ config.HMAC = sha256.New
//~ config.HMACType = "hmac-sha256"
//~ }
if (config == null)
{
config = new Config();
}
if (string.IsNullOrEmpty(config.Location))
{
config.Location = DefaultLocation;
}
if (config.HashFunc == null)
{
config.HashFunc = SHA256Hash;
}
if (config.HMAC == null)
{
config.HMAC = () => new HMACSHA256();
config.HMACType = "hmac-sha256";
}
// Create the salt
//~ s := &Salt{
//~ config: config,
//~ }
var s = new Salt
{
Config = config,
};
// Look for the salt
//~ var raw *logical.StorageEntry
//~ var err error
//~ if view != nil {
//~ raw, err = view.Get(config.Location)
//~ if err != nil {
//~ return nil, fmt.Errorf("failed to read salt: %v", err)
//~ }
//~ }
Logical.StorageEntry raw = null;
if (view != null)
{
raw = view.Get(config.Location);
}
// Restore the salt if it exists
//~ if raw != nil {
//~ s.salt = string(raw.Value)
//~ }
s.SaltValue = raw?.Value?.ToUtf8String();
// Generate a new salt if necessary
//~ if s.salt == "" {
//~ s.salt, err = uuid.GenerateUUID()
//~ if err != nil {
//~ return nil, fmt.Errorf("failed to generate uuid: %v", err)
//~ }
//~ s.generated = true
//~ if view != nil {
//~ raw := &logical.StorageEntry{
//~ Key: config.Location,
//~ Value: []byte(s.salt),
//~ }
//~ if err := view.Put(raw); err != nil {
//~ return nil, fmt.Errorf("failed to persist salt: %v", err)
//~ }
//~ }
//~ }
if (string.IsNullOrEmpty(s.SaltValue))
{
s.SaltValue = Guid.NewGuid().ToString();
s.Generated = true;
if (view != null)
{
raw = new Logical.StorageEntry
{
Key = config.Location,
Value = s.SaltValue.ToUtf8Bytes(),
};
view.Put(raw);
}
}
//~ if config.HMAC != nil {
//~ if len(config.HMACType) == 0 {
//~ return nil, fmt.Errorf("HMACType must be defined")
//~ }
//~ }
if (config.HMAC != null)
{
if (string.IsNullOrEmpty(config.HMACType))
{
throw new Exception("HMACType must be defined");
}
}
//~ return s, nil
return(s);
}
