IEnumerator Start()
{
if (PlayerPrefs.HasKey("Dirty"))
{
if (!SecretData.KeyChainIsSet())
{
PlayerPrefs.DeleteKey("Dirty");
SecretData.CreateDefaultCore();
m_PasscodeControl.StartNewPasscodeRecord();
}
else
{
SecretData.LoadCore();
m_PasscodeControl.StartPasscodeInput();
}
}
else
{
SecretData.CreateDefaultCore();
m_PasscodeControl.StartNewPasscodeRecord();
}
SetAppControl(false);
yield return(new WaitForSeconds(1f));
yield return(new WaitForEndOfFrame());
OverlayCanvas.Instance.Hide();
started = true;
}
void UpdateDisplay(SecretData secret, DiscoveryData discoveryData)
{
if (secret == this.secret)
{
CheckDisplayUnlock();
}
}
public async Task <SecretData <SecretAddress>?> SaveToKeyvault <T>(SecretData <T> secretData)
{
if (secretData == null || secretData.Secret is null)
{
return(null);
}
if (secretData.Secret is SecretAddress)
{
return(secretData as SecretData <SecretAddress>);
}
else
{
var secretName = Guid.NewGuid();
string secretValue;
if (secretData.Secret is string)
{
secretValue = (secretData.Secret as string) !.Trim();
}
else
{
secretValue = JsonSerializer.Serialize(secretData.Secret, EntityConverter.GetJsonSerializerOptions());
}
var kv = await StoreInKeyvault(GetKeyvaultAddress(), secretName.ToString(), secretValue);
return(new SecretData <SecretAddress>(new SecretAddress(kv.Id)));
}
}
public override Image <Rgba32> Embed(Image <Rgba32> baseImage, SecretData secret, Settings settings = null)
{
BitArray secretBits = secret.SecretWithLengthBits;
if (IsEmbedPossible(baseImage, secretBits.Length) == false)
{
throw new InvalidDataException("Secret data is to big for embending.");
}
d = settings?.D ?? 5;
int width = 0;
int height = 0;
int index = 0;
while (index < secretBits.Length)
{
if (width + 8 > baseImage.Width)
{
height += 8;
width = 0;
}
if (height + 8 >= baseImage.Height)
{
break;
}
var luminanceMatrix = GetLuminanceMatrix(baseImage, width, height);
var yMatrix = luminanceMatrix.GetY();
var matrixWithBit = InsertOneBit(yMatrix, secretBits.Get(index), d);
luminanceMatrix = luminanceMatrix.SetY(matrixWithBit);
SetLuminance(baseImage, luminanceMatrix, width, height);
index++;
width += 8;
}
return(baseImage);
}
public override async Task <List <SecretData> > RotateValues(Parameters parameters, RotationContext context, CancellationToken cancellationToken)
{
string currentPrimary = await context.GetSecretValue(new SecretReference(context.SecretName + PrimarySuffix));
if (currentPrimary == null)
{
currentPrimary = "";
}
var newExpiration = DateTimeOffset.MaxValue;
DateTimeOffset newRotateOn = _clock.UtcNow.AddMonths(1);
var newSecondary = new SecretData(currentPrimary, newExpiration, newRotateOn);
using var rng = RandomNumberGenerator.Create();
var bytes = new byte[parameters.Bytes];
rng.GetNonZeroBytes(bytes);
string newPrimaryValue = Convert.ToBase64String(bytes);
var newPrimary = new SecretData(newPrimaryValue, newExpiration, newRotateOn);
return(new List <SecretData>
{
newPrimary,
newSecondary,
});
}
public override Image <Rgba32> Embed(Image <Rgba32> baseImage, SecretData secret, Settings settings = null)
{
BitArray secretBits = secret.SecretWithLengthBits;
if (IsEmbedPossible(baseImage, secretBits.Length) == false)
{
throw new InvalidDataException("Secret data is to big for embending.");
}
Random random = GetRandomGenenator(settings);
int index = 0;
while (index < secretBits.Length)
{
List <Tuple <int, int> > occupied = new List <Tuple <int, int> >();
int width = random.Next(baseImage.Width);
int height = random.Next(baseImage.Height);
var pair = new Tuple <int, int>(width, height);
if (occupied.Contains(pair))
{
continue;
}
occupied.Add(pair);
var pixel = baseImage[width, height];
pixel.R = SetLsb(pixel.R, secretBits[index]);
pixel.B = SetLsb(pixel.B, secretBits[index + 1]);
baseImage[width, height] = pixel;
index += 2;
}
return(baseImage);
}
internal static SecretListResult DeserializeSecretListResult(JsonElement element)
{
Optional <IReadOnlyList <SecretData> > value = default;
Optional <string> nextLink = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("value"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
List <SecretData> array = new List <SecretData>();
foreach (var item in property.Value.EnumerateArray())
{
array.Add(SecretData.DeserializeSecretData(item));
}
value = array;
continue;
}
if (property.NameEquals("nextLink"))
{
nextLink = property.Value.GetString();
continue;
}
}
return(new SecretListResult(Optional.ToList(value), nextLink.Value));
}
public void saveLoadedSecretsFile()
{
if (selectedFile.valid().isFalse())
{
statusMessage("Error: no file loaded");
return;
}
dataGridView.enabled(false);
var secretData = new SecretData();
foreach (var row in dataGridView.rows())
{
if ((row[0] as string).valid())
{
secretData.Credentials.createTypeAndAddToList(
row[0],
row[1],
row[2],
row[3],
row[4]);
}
}
secretData.serialize(selectedFile);
dataGridView.enabled(true);
statusMessage("Saved to file: {0}".format(selectedFile));
}
public static async void StartConnectionAndTestConnectionDuration()
{
//Arrange
SocketManager socketManager = MockData.GetSocketManager();
Account account = SecretData.GetValidTestAccount();
ConnectData validCredentials = new ConnectData
{
Username = account.Username,
Password = account.Password,
ServerCountryCode = "en",
WorldID = "en48"
};
//Act
ConnectResult result1 = await socketManager.StartConnection(validCredentials);
Thread.Sleep(6000);
SocketMessage message = RouteProvider.GetDefaultSendMessage(RouteProvider.SYSTEM_GETTIME);
var result = await socketManager.Emit(message);
Thread.Sleep(600000);
//Assert
Assert.True(socketManager.IsConnected);
await socketManager.StopConnection(true);
}
private async Task <SecretData> GetTrackedSecretAsync(string secretName)
{
var context = new Dictionary <string, object>
{
["SecretEngine Type"] = "KeyValue",
["SecretEngine Version"] = _options.KeyValueVersion
};
var isSuccessful = false;
using (DependencyMeasurement measurement = DependencyMeasurement.Start())
{
try
{
_logger.LogTrace("Getting a secret {SecretName} from HashiCorp Vault {VaultUri}...", secretName, _vaultClient.Settings.VaultServerUriWithPort);
SecretData result = await ReadSecretDataAsync(_secretPath);
isSuccessful = true;
return(result);
}
finally
{
_logger.LogTrace("{Result} secret from HashiCorp Vault {VaultUri}", isSuccessful ? "Got" : "Couldn't get", _vaultClient.Settings.VaultServerUriWithPort);
if (_options.TrackDependency)
{
_logger.LogDependency(DependencyName, secretName, _vaultClient.Settings.VaultServerUriWithPort, isSuccessful, measurement, context);
}
}
}
}
public void Initialize(SecretData data, string word)
{
Director.GetManager <SecretsManager>().OnDiscoveryAssigned += UpdateDisplay;
this.secret = data;
codedText.text = revealedText.text = word;
CheckDisplayUnlock();
}
public byte[] CalculateSecretDataHash(byte[] value)
{
if (SecretData == null)
{
return(null);
}
return(DataContext.Hasher.ComputeHash(SecretData.Concat(value).ToArray()));
}
public byte[] CalculatePasswordHash(string value)
{
if (SecretData == null)
{
return(null);
}
return(DataContext.Hasher.ComputeHash(SecretData.Concat(Encoding.Default.GetBytes(value)).ToArray()));
}
private Image <Rgba32> EncryptAndSave(StegoAlgorithm algorithm, byte[] secretDataBytes, string fileName)
{
var secretData = new SecretData(secretDataBytes);
var result = algorithm.Embed(Image.Load(FileHelper.GetPathToImage("sky.jpg")), secretData, null);
result.Save(fileName);
return(result);
}
public EditSecretData(SecretData secretData)
{
InitializeComponent();
descriptionBox.Text = secretData.Description;
loginBox.Text = secretData.Login;
passBox.Text = secretData.Password;
urlBox.Text = secretData.Url;
}
public static string Serialize(RetrievedSecrets secrets)
{
var secretsList = secrets.Secrets
.Select(kvp => SecretData.FromSecret(kvp.Key, kvp.Value))
.OrderBy(s => s.Name)
.ToList();
return(JsonSerializer.Serialize(secretsList));
}
public void Save <T>(string key, T data)
{
var secretKey = new SecretData <T>(data);
KeyStore.SecretKeyEntry entry = new KeyStore.SecretKeyEntry(secretKey);
ks.SetEntry(key.Trim(), entry, prot);
Save();
}
public void SetEncryption(PasswordTypes passwordType, string?password = null)
{
// check if still encrpyted
if (RequiresPassword == true)
{
// have to decrypt to be able to re-encrypt
throw new WinAuthEncryptedSecretDataException();
}
if (passwordType == PasswordTypes.None)
{
RequiresPassword = false;
EncryptedData = null;
PasswordType = passwordType;
}
else
{
using var ms = new MemoryStream();
// get the plain version
var settings = new XmlWriterSettings();
settings.Indent = true;
settings.Encoding = Encoding.UTF8;
using (var encryptedwriter = XmlWriter.Create(ms, settings))
{
var encrpytedData = EncryptedData;
var savedpasswordType = PasswordType;
try
{
PasswordType = PasswordTypes.None;
EncryptedData = null;
WriteToWriter(encryptedwriter);
}
finally
{
PasswordType = savedpasswordType;
EncryptedData = encrpytedData;
}
}
var data = ByteArrayToString(ms.ToArray());
// update secret hash
using (var sha1 = SHA1.Create())
{
SecretHash = sha1.ComputeHash(Encoding.UTF8.GetBytes(SecretData.ThrowIsNull(nameof(SecretData))));
}
// encrypt
EncryptedData = EncryptSequence(data, passwordType, password);
PasswordType = passwordType;
if (PasswordType == PasswordTypes.Explicit)
{
SecretData = null;
RequiresPassword = true;
}
}
}
public void Should_Parse_Secret()
{
var secretData = SecretData.FromSecret("9TaJJxTQ6uFYg4kabVag98KyF37KpgttZLrn2DtWj9LuwQi53urzHX4xAGJo6WU5VyoP2KH2XETbtc");
Assert.Equal(secretData.WalletId.ToString(), "447ef7db-85e6-4aad-8547-a503c15c853b");
var hexKey = System.BitConverter.ToString(secretData.WalletPrivateKey.ToBytes()).Replace("-", string.Empty);
Assert.Equal(hexKey.ToLower(), "3c5b6a54a3412d5cd7bc7e54624a53ab0e30e9c5e914786bf9ac28887d68b476");
Assert.Equal(secretData.Coin, "btc");
Assert.Equal(secretData.Network, Network.TestNet);
}
public void LSB_Embed_And_Decode_SecretDataLength()
{
var lsb = AlgorithmFactory.Create(AlgorithmEnum.Lsb);
byte[] secretDataBytes = System.IO.File.ReadAllBytes(FileHelper.GetPathToSecretData());
var secretData = new SecretData(secretDataBytes);
var imageWithSecret = lsb.Embed(Image.Load(FileHelper.GetPathToImage()), secretData, null);
int readedLength = lsb.ReadSecretLength(imageWithSecret, null);
Assert.Equal(secretDataBytes.Length, readedLength);
}
public static async void EstablishConnectionTestIfConnecting()
{
//Arrange
ISocketRepository socketRepository = MockData.GetISocketRepository(true);
Account account = SecretData.GetValidTestAccount();
//Act
var result = await socketRepository.EstablishConnection(account);
//Assert
Assert.True(result);
}
// Use this for initialization
void Start()
{
initialRotationZ = 0;
rotation = 0;
initialRotationVector.x = 0;
initialRotationVector.y = 0;
colls = new List <GameObject>();
GD = new GeneralData();
SD = new SecretData();
GD.gestureName = "highknees";
firstread = true;
}
private void AddSecrets(Dictionary <string, string> data, SecretData secretData, IDictionary <string, object> secretDictionary)
{
foreach (var kvp in secretDictionary)
{
// if the manager cannot load this key value pair just skip it
if (!_manager.Load(secretData, kvp.Key))
{
continue;
}
var key = _manager.GetKey(secretData, kvp.Key);
data.Add(key, kvp.Value?.ToString());
}
}
// Добавити секретні дані
public void AddSecretData(int userId, SecretData data, string key)
{
ctx.Secrets.Add(new Entities.Secret()
{
Login = sp.Encrypt(key, data.Login),
Password = sp.Encrypt(key, data.Password),
Description = sp.Encrypt(key, data.Description),
Url = sp.Encrypt(key, data.Url),
UserId = Convert.ToInt32(userId),
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now,
});
ctx.SaveChanges();
}
// Use this for initialization
void Start()
{
initialRotationZ = 0;
rotation = 0;
initialRotationVector.x = 0;
initialRotationVector.y = 0;
colls = new List <GameObject>();
GD = new GeneralData();
SC = ParentCircle.GetComponent <StartCircle>();
SC.GD = GD;
SD = new SecretData();
GD.gestureName = "none";
firstread = true;
}
/// <summary>
/// Retrieves the secret value, based on the given name
/// </summary>
/// <param name="secretName">The name of the secret key</param>
/// <returns>Returns a <see cref="Secret"/> that contains the secret key</returns>
/// <exception cref="ArgumentException">Thrown when the <paramref name="secretName"/> is blank.</exception>
public virtual async Task <Secret> GetSecretAsync(string secretName)
{
Guard.NotNullOrWhitespace(secretName, nameof(secretName),
$"Requires a non-blank secret name to look up the secret in the HashiCorp Vault {Options.KeyValueVersion} KeyValue secret engine");
SecretData result = await GetTrackedSecretAsync(secretName);
if (result.Data.TryGetValue(secretName, out object value) && value != null)
{
var version = result.Metadata?.Version.ToString();
return(new Secret(value.ToString(), version));
}
return(null);
}
public static IConfigurationBuilder AddVault(this IConfigurationBuilder builder)
{
IConfigurationRoot buildConfig = builder.Build();
//IAuthMethodInfo authenticationInfo = new TokenAuthMethodInfo(VaultAccessToken);
IAuthMethodInfo authenticationInfo = new AppRoleAuthMethodInfo(VaultRoleId, VaultSecretId);
VaultClientSettings vaultClientSettings = new VaultClientSettings(VaultServerUri, authenticationInfo);
IVaultClient client = new VaultClient(vaultClientSettings);
SecretData appSecrets = client.V1.Secrets.KeyValue.V2.ReadSecretAsync("applications/vault-test").GetAwaiter().GetResult().Data;
IEnumerable <KeyValuePair <string, string> > secretsForConfiguration = appSecrets.Data.Select(x => new KeyValuePair <string, string>($"vault-startup:{x.Key}", x.Value.ToString()));
return(builder.AddInMemoryCollection(secretsForConfiguration));
}
public void createNewSecretsFile()
{
var secretData = new SecretData();
var fileName = "What is the new file name".askUser();
if (fileName.valid())
{
if (fileName.extension(".xml").isFalse())
{
fileName += ".xml";
}
selectedFile = directory.getCurrentDirectory().pathCombine(fileName);
secretData.serialize(selectedFile);
statusMessage("Created new File: {0}".format(selectedFile));
}
}
void SecretClicked(SecretData secret)
{
_selectedSecret = secret;
selectedSecretText.enabled = true;
selectedSecretText.text = secret.name;
DiscoveryData assignedDiscovery = Director.GetManager <SecretsManager>().GetAssignedDiscovery(secret);
if (assignedDiscovery == null)
{
assignedDiscoveryText.text = "No assigned discovery";
}
else
{
assignedDiscoveryText.text = assignedDiscovery.name;
}
}
private async void SubmitBtn_Click(object sender, RoutedEventArgs e)
{
if (!SecretValidator.CheckDescription(descriptionBox.Text))
{
MessageBox.Show(SecretValidator.CheckDescriptionMessage());
return;
}
if (!SecretValidator.CheckUrl(urlBox.Text))
{
MessageBox.Show(SecretValidator.CheckUrlMessage());
return;
}
if (!SecretValidator.CheckLogin(loginBox.Text) && !SecretValidator.CheckEmail(loginBox.Text))
{
MessageBox.Show(SecretValidator.CheckLoginMessage());
return;
}
if (!SecretValidator.CheckPassword(passBox.Text))
{
MessageBox.Show(SecretValidator.CheckPasswordMessage());
return;
}
SecretData secretData = new SecretData();
secretData.Url = urlBox.Text;
secretData.Description = descriptionBox.Text;
secretData.Login = loginBox.Text;
secretData.Password = passBox.Text;
bool res = await service.AddSecretDataAsync(token, key, secretData);
if (res)
{
MessageBox.Show("Дані добавлено!");
this.DialogResult = true;
this.Close();
}
else
{
MessageBox.Show("Щось не так...");
}
}
public PremiumHandler(IMediator mediator) {
_mediator = mediator;
_secretData = DomainEvilGlobal.SecretData;
_settings = DomainEvilGlobal.Settings;
}
