private UserKeys GenerateNewKeyPair()
{
var rsa = new Chilkat.Rsa();
rsa.GenerateKey(RsaKeySize);
var publicKey = rsa.ExportPublicKey();
var privateKey = rsa.ExportPrivateKey();
var symetricKey = EncryptionManager.GenerateSymmetricKey();
var rsaEncryptor = new Chilkat.Rsa {
EncodingMode = EncodingMode
};
rsaEncryptor.ImportPrivateKey(privateKey);
// Encrypted with private so that public key can get access to symmetric key
var encryptedSymetricKey = rsaEncryptor.EncryptStringENC(symetricKey, true);
// Encrypted with application key so that the application can manage access to private keys
var encryptedPrivateKey = EncryptionManager.Encrypt(privateKey, string.Empty);
return(UserKeys.Create(encryptedPrivateKey, publicKey, encryptedSymetricKey));
}
private void ReadUserKeys(string filename)
{
UserKeys userKeys = XmlFile.ReadFile <UserKeys>(filename);
this.masterPublicKey = Convert.FromBase64String(userKeys.MasterKeyPublicKey);
this.userPrivateKey = Convert.FromBase64String(userKeys.UserPrivateKey);
this.userSignKeys = Convert.FromBase64String(userKeys.UserSignKeys);
this.userkeysLoaded = true;
this.labelPickKeysStatus.Text = "OK";
}
public static UserKeys Create(string encryptedPrivateKey, string publicKey, string encryptedSymetricKey)
{
var keyPair = new UserKeys
{
EncryptedPrivateKey = encryptedPrivateKey,
PublicKey = publicKey,
EncryptedSymetricKey = encryptedSymetricKey
};
return(keyPair);
}
private void buttonGenerateKeypairsForUser_Click(object sender, EventArgs e)
{
try
{
if (string.IsNullOrEmpty(this.textBoxNewUserId.Text))
{
MessageBox.Show("You must enter a username");
return;
}
this.newUserId = GuidCreator.CreateGuidFromString(this.textBoxNewUserId.Text);
if (this.masterKeypair == null)
{
MessageBox.Show("You must load master key pair first");
return;
}
string filename = FileDialogs.AskUserForFileNameToSaveIn();
if (!string.IsNullOrEmpty(filename))
{
if (!Path.HasExtension(filename))
{
filename = filename + ".xml";
}
this.signKeyPair = DataSigner.GenerateSignKeyPair();
IPreService proxy = GetPreProxy();
this.userKeypair = proxy.GenerateKeyPair();
proxy = GetPreProxy();
this.delegationToken.ToUser = proxy.GenerateDelegationKey(this.masterKeypair.Private, this.userKeypair.Public);
IGatewayService gateWayproxy = GetServiceProxy();
gateWayproxy.RegisterUser(this.myId, this.newUserId, this.delegationToken, this.signKeyPair.PublicOnly);
UserKeys uk = new UserKeys();
uk.MasterKeyPublicKey = Convert.ToBase64String(this.masterKeypair.Public);
uk.UserPrivateKey = Convert.ToBase64String(this.userKeypair.Private);
uk.UserSignKeys = Convert.ToBase64String(this.signKeyPair.PublicAndPrivate);
XmlFile.WriteFile(uk, filename);
MessageBox.Show("Done");
}
}
catch (Exception ex)
{
MessageBox.Show("Error: " + ex.Message);
Logger.LogError("Error generating user keypair", ex);
}
}
private RSAParameters ConvetToRsaParameters(UserKeys userKeys)
{
return(new RSAParameters
{
D = userKeys.D,
DP = userKeys.DP,
DQ = userKeys.DQ,
P = userKeys.P,
Q = userKeys.Q,
InverseQ = userKeys.InverseQ,
Exponent = userKeys.Exponent,
Modulus = userKeys.Modulus
});
}
public void GenerateKeys()
{
if (ownKeys != null)
{
oldOwnKeys = ownKeys;
}
ownKeys = new UserKeys();
ownKeys.preKey = Encrypt.NewKeypair();
ownKeys.identKey = Encrypt.NewSingKeypair();
for (int i = 0; i < 64; i++)
{
ownKeys.oneTimeKeys[i] = Encrypt.NewKeypair();
}
SaveOwnKeys(true);
Encrypt.SetOwnKeys(ownKeys, null);
}
public UserKeys GetUserKeyPair(string userReference)
{
var userKeys = KeyStoreRepo.GetKeyPairByUserReference(userReference);
if (userKeys != null)
{
return(UserKeys.Create(userKeys.PrivateKeyEncrypted, userKeys.PublicKey, userKeys.SymmetricKeyEncrypted));
}
// TODO: Ensure this is locked for race conditions
var keyCombo = GenerateNewKeyPair();
KeyStoreRepo.Add(new UserKeyEntity(userReference, keyCombo.EncryptedPrivateKey, keyCombo.PublicKey, keyCombo.EncryptedSymetricKey));
KeyStoreRepo.Save();
return(keyCombo);
}
////////////////////////////////////////////////////////////////////////////////
//
////////////////////////////////////////////////////////////////////////////////
internal UserKeys[] GetUserHashes(Byte[] hBootKey)
{
int size = 0;
UIntPtr hKey = new UIntPtr();
Int32 type = 0;
Dictionary <Int32, String> ridMapping = new Dictionary <Int32, String>();
String[] namesSubKeys = Registry.LocalMachine.OpenSubKey(@"SAM\SAM\Domains\Account\Users\Names").GetSubKeyNames();
foreach (String name in namesSubKeys)
{
if (advapi32.RegOpenKeyEx(Reg.HKEY_LOCAL_MACHINE, @"SAM\SAM\Domains\Account\Users\Names\" + name, 0, Reg.KEY_QUERY_VALUE, out hKey) != 0)
{
Console.WriteLine("[-] Error opening key '{0}\\{1}", @"SAM\SAM\Domains\Account\Users\Names\" + name, "");
return(null);
}
if (advapi32.RegQueryValueEx(hKey, "", 0, ref type, IntPtr.Zero, ref size) != 0)
{
Console.WriteLine("[-] [-] Error querying value '{0}\\{1}", @"SAM\SAM\Domains\Account\Users\Names\" + name, "");
return(null);
}
ridMapping[type] = name;
}
String[] secretSubKeys = Registry.LocalMachine.OpenSubKey(@"SAM\SAM\Domains\Account\Users").GetSubKeyNames();
UserKeys[] userKeys = new UserKeys[secretSubKeys.Length - 1];
for (Int32 i = 0; i < secretSubKeys.Length; i++)
{
if (secretSubKeys[i] != "Names")
{
userKeys[i].rid = Int32.Parse(secretSubKeys[i], System.Globalization.NumberStyles.HexNumber);
userKeys[i].userName = ridMapping[userKeys[i].rid];
userKeys[i].f = (Byte[])Reg.ReadRegKey(Reg.HKEY_LOCAL_MACHINE, @"SAM\SAM\Domains\Account\Users\" + secretSubKeys[i], "F");
userKeys[i].v = (Byte[])Reg.ReadRegKey(Reg.HKEY_LOCAL_MACHINE, @"SAM\SAM\Domains\Account\Users\" + secretSubKeys[i], "V");
userKeys[i].userPasswordHint = (Byte[])Registry.LocalMachine.OpenSubKey(@"SAM\SAM\Domains\Account\Users\" + secretSubKeys[i]).GetValue("UserPasswordHint");
//userKeys[i].userPasswordHint = (Byte[])Reg.ReadRegKey(Reg.HKEY_LOCAL_MACHINE, @"SAM\SAM\Domains\Account\Users\" + secretSubKeys[i], "UserPasswordHint");
}
}
return(userKeys);
}
public RootFolderInfo(Options opt, IEnumerable <string> paths = null)
: base("", "", Guid.NewGuid())
{
GeneratedKeys = ReadKeyDatabase(opt.dbfilename);
UserKeys = ReadKeyDatabase(opt.userfilename);
ComponentID = opt.componentid;
m_opt = opt;
string id;
if (!GeneratedKeys.TryGetValue(DIR_SEP, out id))
{
id = Guid.NewGuid().ToString();
}
if (UserKeys.ContainsKey(DIR_SEP))
{
id = UserKeys[DIR_SEP];
}
this.ID = id;
Add(paths);
}
public void SetEncInstance(UserKeys enc)
{
ownKeys = enc;
}
public void Add(string path)
{
if (string.IsNullOrEmpty(path))
{
return;
}
bool isDir = false;
if (path.EndsWith(DIR_SEP))
{
isDir = true;
path = path.Substring(0, path.Length - 1);
}
List <string> folders = new List <string>();
string filename = null;
while (!string.IsNullOrEmpty(path))
{
string sourcepath = System.IO.Path.GetDirectoryName(path);
string elname = System.IO.Path.GetFileName(path);
folders.Add(elname);
path = sourcepath;
if (path.EndsWith(DIR_SEP))
{
path = path.Substring(0, path.Length - 1);
}
}
if (!isDir)
{
filename = folders[0];
folders.RemoveAt(0);
}
IFolder cur = this;
folders.Reverse();
StringBuilder sbp = new StringBuilder();
foreach (var f in folders)
{
sbp.Append(f);
sbp.Append(DIR_SEP);
FolderInfo next;
if (!cur.Folders.TryGetValue(f, out next))
{
//We have a new folder
string id;
if (!GeneratedKeys.TryGetValue(sbp.ToString(), out id))
{
id = Guid.NewGuid().ToString();
GeneratedKeys.Add(sbp.ToString(), id);
}
Guid g;
try { g = new Guid(id); }
catch
{
g = Guid.NewGuid();
GeneratedKeys[sbp.ToString()] = g.ToString();
Console.Error.WriteLine("Unable to parse {0} into a GUID, I told you not to edit the file!!!{1}A new GUID will be used: {2}", id, Environment.NewLine, g);
}
string userkey;
if (!UserKeys.TryGetValue(sbp.ToString(), out userkey))
{
userkey = g.ToString();
}
next = new FolderInfo(f, userkey, g);
cur.Folders.Add(f, next);
}
cur = next;
}
if (!string.IsNullOrEmpty(filename))
{
sbp.Append(filename);
string id;
if (!GeneratedKeys.TryGetValue(sbp.ToString(), out id))
{
GeneratedKeys.Add(sbp.ToString(), id = Guid.NewGuid().ToString());
}
if (UserKeys.ContainsKey(sbp.ToString()))
{
id = UserKeys[sbp.ToString()];
}
string fullpath = System.IO.Path.Combine(m_opt.fileprefix, sbp.ToString()).Replace(DIR_SEP, "\\");
cur.Files.Add(filename, new FileInfo(filename, id, fullpath));
}
}
/*public float age {
* get {
* return Mathf.Clamp((float)(BoltNetwork.serverFrame - ServerFrame) * BoltNetwork.frameDeltaTime, 0f, 0.5f);
* }
* }*/
public UserCommand()
{
Down = new UserKeys();
Pressed = new UserKeys();
Last = new UserKeys();
}
