void HandleKeyboard()
{
var ev = Event.current;
if (ev.type != EventType.KeyDown)
{
return;
}
switch (ev.keyCode)
{
case KeyCode.Escape: Close(); break;
case KeyCode.DownArrow: focusedIdx++; break;
case KeyCode.UpArrow: focusedIdx--; break;
case KeyCode.Backspace: if (string.IsNullOrEmpty(query))
{
queryType = KeyTypes.SelectGameObject; break;
}
else
{
return;
}
case KeyCode.Return: Apply(ev.shift ? -1 : focusedIdx); break;
default: return;
}
ev.Use();
}
/// <summary>
/// 扇区认证
/// </summary>
/// <param name="KeyType"></param>
/// <param name="SectorNum"></param>
/// <param name="KeyBuf">密码</param>
/// <returns></returns>
public static bool SectorAuthtication(KeyTypes KeyType, byte SectorNum, byte[] KeyBuf)
{
try
{
byte Cmd = (byte)CMD_TABLE.AUTHTICATION;
byte Len = 8;
byte[] inBuf = new byte[32];
byte[] outBuf = new byte[32];
inBuf[0] = (byte)KeyType; //密钥模式
inBuf[1] = SectorNum; //数据块
for (int i = 0; i < 6; i++)
{
inBuf[2 + i] = KeyBuf[i];
}
if (Ioctl(Cmd, inBuf, Len, out outBuf) == false)
{
return(false);
}
if (outBuf[0] == 0x00)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
return(false);
}
}
public Key(string name, KeyTypes type, bool enabled)
: this()
{
Name = name;
Type = type;
Enabled = enabled;
}
private static Dictionary <string, KeyTypes> GetKeyboardKeys(KeyTypes types)
{
var res = new Dictionary <string, KeyTypes>(_comparer);
if (types.HasFlag(KeyTypes.Common))
{
var allFnKeyNames = typeof(Keyboard)
.GetFields(BindingFlags.Public | BindingFlags.Static)
.Select(x => (string)x.GetValue(null));
foreach (var keyName in allFnKeyNames)
{
res.Add(keyName, KeyTypes.Common);
}
}
if (types.HasFlag(KeyTypes.Character))
{
foreach (var charKeyName in _characterKeyNames)
{
res.Add(charKeyName, KeyTypes.Character);
}
}
return(res);
}
public static KeyTypes PrevKey(KeyTypes key)
{
IList<KeyTypes> keys = Enum.GetValues(typeof(KeyTypes)).Cast<KeyTypes>().ToList<KeyTypes>();
int index = keys.ToList<KeyTypes>().IndexOf(key);
if (index == 0) return keys.ElementAt<KeyTypes>(keys.Count-1);
else return keys.ElementAt<KeyTypes>(index - 1);
}
public PrivateKey(KeyTypes keyType = KeyTypes.K1)
{
if (keyType != KeyTypes.K1 && keyType != KeyTypes.R1)
{
throw new InvalidKeyException(Resources.WrongKeyType);
}
KeyType = keyType;
using (RandomNumberGenerator r = RandomNumberGenerator.Create())
{
Value = new byte[Length];
r.GetBytes(Value);
}
D = Value.ToInt256();
if (keyType == KeyTypes.R1)
{
ToR1Key(true);
}
else
{
ToK1Key(true);
}
}
public static Key KeyExchange(KeyTypes keyType, Key privateKey, Key publicKey)
{
if (keyType == KeyTypes.Ed25519)
{
return(Ed25519Key.KeyExchangeInternal(privateKey as Ed25519Key, publicKey as Ed25519Key));
}
throw new ArgumentException(string.Format("Key type not implemented {0}", keyType));
}
public override void Authenticate(IntPtr Handle, int Proto, KeyTypes KeyType, byte Sector)
{
byte KeyT = KeyType == KeyTypes.TypeA ? (byte)0x60 : (byte)0x61;
Transmit(Handle, Proto, new byte[] { 0xFF, 0x86, 0x00, 0x00, 0x05,
0x01, 0x00, Sector, KeyT, 0x01 });
return;
}
public static Key Generate(KeyTypes keyType, byte[] seed = null) // default
{
if (keyType == KeyTypes.Ed25519)
{
return(new Ed25519Key(seed));
}
throw new ArgumentException(string.Format("Key type not implemented {0}", keyType));
}
public static ushort GetKeyBytes(KeyTypes keyType, bool isPrivateKey, bool padding = true)
{
if (keyType == KeyTypes.Ed25519)
{
return((ushort)((isPrivateKey ? ED25519_SECRETKEY_BYTES : ED25519_PUBLICKEY_BYTES) + (padding ? PADDING_BYTES : 0)));
}
throw new ArgumentException(string.Format("Key type not implemented {0}", keyType));
}
public Key(string name, KeyTypes type, bool enabled)
{
this.Name = name;
this.Type = type;
this.Enabled = enabled;
this.Region = null;
this.Items = new List<Terraria.Item>();
}
public Key(string name, KeyTypes type, bool enabled)
{
this.Name = name;
this.Type = type;
this.Enabled = enabled;
this.Region = null;
this.Items = new List <Terraria.Item>();
}
public static ushort GetSignatureBytes(KeyTypes keyType, bool padding = true)
{
if (keyType == KeyTypes.Ed25519)
{
return((ushort)(ED25519_SIGNATURE_BYTES + (padding ? PADDING_BYTES : 0)));
}
throw new ArgumentException(string.Format("Signature type for key not implemented {0}", keyType));
}
public AppData(IConfiguration config)
{
ConnectionString = config.GetConnectionString("AllAboutFood");
var cp = new ClaimsPrincipal();
Languages = new Languages(Claim.DbContext <Language>(cp, ConnectionString).Read());
States = new States(Claim.DbContext <State>(cp, ConnectionString).Read());
DictionaryKeyTypes = new KeyTypes(Claim.DbContext <KeyType>(cp, ConnectionString).Read());
}
public static bool CheckKeyType(KeyTypes keyType, bool throwException)
{
var valid = Enum.IsDefined(typeof(KeyTypes), keyType);
if (!valid && throwException)
{
throw new ArgumentException(string.Format("Invalid key type {0}", keyType));
}
return(valid);
}
public KeyController(Vector3 nodePos, InteractableManager interactableManager, InteractableView keyPrefab, KeyTypes keyType)
{
this.interactableManager = interactableManager;
this.keyType = keyType;
GameObject key = GameObject.Instantiate <GameObject>(keyPrefab.gameObject);
interactableView = key.GetComponent <KeyView>();
interactableView.SetController(this);
interactableView.transform.position = nodePos;
}
/// <summary>
/// Creates a new <see cref="GeneralKeyHeader"/> with the
/// <paramref name="reader"/> from which to read information from.
/// </summary>
/// <param name="reader">The <see cref="BinaryReader"/>
/// from which to source the information from.</param>
public GeneralKeyHeader(BinaryReader reader)
{
this.keyType = (KeyTypes)reader.ReadByte();
this.version = reader.ReadByte();
this.reserved = reader.ReadUInt16();
this.algorithmId = reader.ReadUInt32();
this.keyTypeId = (KeyIdentifiers)reader.ReadUInt32();
this.bitLength = reader.ReadUInt32();
this.exponent = reader.ReadUInt32();
}
public void KeyCollected(KeyTypes key)
{
for (int i = 0; i < physicalGates.Count; i++)
{
while (i < physicalGates.Count && physicalGates[i].GetKey() == key)
{
physicalGates[i].Disable();
physicalGates.RemoveAt(i);
}
}
}
public override void LoadKey(IntPtr Handle, int Proto, KeyTypes KeyType, byte[] KeyData)
{
if (KeyData.Length != 6)
{
throw new NotSupportedException("Keys must be 6 byte long");
}
byte KeyT = KeyType == KeyTypes.TypeA ? (byte)0x60 : (byte)0x61;
Transmit(Handle, Proto, new byte[] { 0xFF, 0x82, 0x00, KeyT, 0x06,
KeyData[0], KeyData[1], KeyData[2], KeyData[3], KeyData[4], KeyData[5] });
return;
}
private string Sanitize(KeyType keyType, string input)
{
DataType dataType;
if (KeyTypes.TryGetValue(keyType, out dataType))
{
return(Sanitize(dataType, input));
}
else
{
return(Sanitize(DataType.String, input));
}
}
void HandleQuery()
{
EditorGUILayout.BeginHorizontal(GUILayout.Height(20));
EditorGUILayout.LabelField(Styles.keyGUIs[(int)queryType], GUILayout.Width(20));
var newQ = SearchField(query, GUILayout.ExpandWidth(true));
if (newQ != query)
{
query = newQ;
queryType = (KeyTypes)Math.Max(0, Styles.keys.IndexOf(query.Length > 0 ? query[0] : ' '));
ReloadResults(queryType == KeyTypes.SelectGameObject ? query : query.Substring(1));
}
EditorGUILayout.EndHorizontal();
}
public void AddDataRow()
{
var newRow = new Dictionary <KeyType, string>();
foreach (var key in CategoryKeys)
{
DataType dataType;
if (KeyTypes.TryGetValue(key, out dataType))
{
newRow[key] = Sanitize(dataType, "");
}
}
Data.Add(newRow);
}
/// <summary>
/// Loads a key from KeyChangerConfig.json.
/// </summary>
/// <param name="type">The type of key to load.</param>
/// <returns>The key with all the required data.</returns>
public static Key LoadKey(KeyTypes type, Region region = null)
{
Key key;
switch (type)
{
case KeyTypes.Temple:
key = new Key("temple", KeyTypes.Temple, Config.contents.EnableTempleKey);
key.Items = GetItems(Config.contents.TempleKeyItem);
key.Region = TShock.Regions.GetRegionByName(Config.contents.TempleRegion);
break;
case KeyTypes.Jungle:
key = new Key("jungle", KeyTypes.Jungle, Config.contents.EnableJungleKey);
key.Items = GetItems(Config.contents.JungleKeyItem);
key.Region = TShock.Regions.GetRegionByName(Config.contents.JungleRegion);
break;
case KeyTypes.Corruption:
key = new Key("corruption", KeyTypes.Corruption, Config.contents.EnableCorruptionKey);
key.Items = GetItems(Config.contents.CorruptionKeyItem);
key.Region = TShock.Regions.GetRegionByName(Config.contents.CorruptionRegion);
break;
case KeyTypes.Crimson:
key = new Key("crimson", KeyTypes.Crimson, Config.contents.EnableCrimsonKey);
key.Items = GetItems(Config.contents.CrimsonKeyItem);
key.Region = TShock.Regions.GetRegionByName(Config.contents.CrimsonRegion);
break;
case KeyTypes.Hallowed:
key = new Key("hallowed", KeyTypes.Hallowed, Config.contents.EnableHallowedKey);
key.Items = GetItems(Config.contents.HallowedKeyItem);
key.Region = TShock.Regions.GetRegionByName(Config.contents.HallowedRegion);
break;
case KeyTypes.Frozen:
key = new Key("frozen", KeyTypes.Frozen, Config.contents.EnableFrozenKey);
key.Items = GetItems(Config.contents.FrozenKeyItem);
key.Region = TShock.Regions.GetRegionByName(Config.contents.FrozenRegion);
break;
default:
return(null);
}
return(key);
}
static public IKey GetKeyByType(KeyTypes keyType)
{
switch (keyType)
{
case KeyTypes.GeneratedKey:
return(new KeyByGen());
case KeyTypes.StockedKey:
return(new KeyByStock());
case KeyTypes.VendorKey:
return(new KeyByVendor());
default:
return(null);
}
}
/// <summary>
/// Athenthicates a sector against a key
/// </summary>
/// <param name="BlockAddress">The address to read</param>
/// <param name="Key">The 6 Byte Key</param>
/// <param name="KeyType">The keys type (A or B)</param>
public void Athenthicate(byte BlockAddress, byte[] Key, KeyTypes KeyType)
{
if (Disposed)
{
throw new Exception(DisposedError);
}
if (Key.Count() != 6)
{
throw new Exception($"Invalid input all Keys are 6 bytes long where yous was:{Key.Count()}");
}
int result = rfidlib_aip_iso14443A.MFCL_Authenticate(Owner.ReaderHandle, CardHandle, BlockAddress, (byte)KeyType, Key);
if (result != 0)
{
throw new Exception($"Failed to athenticate block {BlockAddress} with {KeyType} with result:{result}");
}
}
public bool ValidateKey(char key, KeyTypes keyType)
{
switch (keyType)
{
case KeyTypes.IsNumber:
return(Enumerable.Contains(numbers, key));
case KeyTypes.IsOperator:
return(Enumerable.Contains(operators, key));
case KeyTypes.IsResultSign:
return(Enumerable.Contains(resultSign, key));
case KeyTypes.IsSpecialKeys:
return(Enumerable.Contains(specialKeys, key));
}
return(false);
}
public override void SetController(InteractableController interactableController)
{
this.keyController = (KeyController)interactableController;
KeyTypes keyType = keyController.GetKeyType();
if (keyType == KeyTypes.BLUE)
{
rendrer.material.color = blue;
}
else if (keyType == KeyTypes.RED)
{
rendrer.material.color = red;
}
else if (keyType == KeyTypes.YELLOW)
{
rendrer.material.color = yellow;
}
}
public void KeyCollected(KeyTypes key)
{
for (int i = 0; i < gates.Count; i++)
{
if (gates[i].key == key)
{
int dir = -1, node = -1, setdir1 = -1, setdir2 = -1;
if (GetNodeLocation(gates[i].node1).x < GetNodeLocation(gates[i].node2).x)
{
dir = 2;
setdir1 = 2;
setdir2 = 3;
node = gates[i].node1;
}
if (GetNodeLocation(gates[i].node1).z > GetNodeLocation(gates[i].node2).z)
{
dir = 0;
setdir2 = 1;
setdir1 = 0;
node = gates[i].node1;
}
if (GetNodeLocation(gates[i].node2).z > GetNodeLocation(gates[i].node1).z)
{
dir = 0;
setdir2 = 0;
setdir1 = 1;
node = gates[i].node2;
}
if (GetNodeLocation(gates[i].node2).x < GetNodeLocation(gates[i].node1).x)
{
dir = 2;
setdir2 = 2;
setdir1 = 3;
node = node = gates[i].node2;
}
graph[gates[i].node1].connections[setdir1] = gates[i].node2;
graph[gates[i].node2].connections[setdir2] = gates[i].node1;
view.DrawPath(dir, GetNodeLocation(node));
}
}
view.KeyCollected(key);
}
static string GetKeyDiretory(KeyTypes keyType, RsaDss rsaDss)
{
var baseDirectory =
keyType == KeyTypes.UserPrivate ? Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) : Environment.GetEnvironmentVariable("ALLUSERSPROFILE");
var rsaDssSubfolder =
rsaDss == RsaDss.RSA ? "RSA" : "DSS";
string userSubfolder;
switch (keyType)
{
case KeyTypes.UserPrivate:
userSubfolder = WindowsIdentity.GetCurrent().User.Value;
break;
case KeyTypes.LocalSystemPrivate:
userSubfolder = "S-1-5-18";
break;
case KeyTypes.LocalServicePrivate:
userSubfolder = "S-1-5-19";
break;
case KeyTypes.NetworkServicePrivate:
userSubfolder = "S-1-5-20";
break;
case KeyTypes.SharedPrivate:
userSubfolder = "MachineKeys";
break;
default:
throw new NotImplementedException();
}
return(Path.Combine(
baseDirectory,
@"Microsoft\Crypto",
rsaDssSubfolder,
userSubfolder
));
}
public static bool TryParse(string source, out KeyTypes keyType)
{
keyType = default(KeyTypes);
bool isValid = false;
switch (source)
{
case "networkKey":
keyType = KeyTypes.NetworkKey;
isValid = true;
break;
case "passPhrase":
keyType = KeyTypes.PassPhrase;
isValid = true;
break;
}
return(isValid);
}
/// <summary>
/// Converts enum KeyTypeMode (ManagedNativeWifi) to internal type WiFiKeyType.
/// </summary>
private WiFiKeyType KeyTypeModeConverter(KeyTypes keyType)
{
WiFiKeyType wiFiKeyType = default(WiFiKeyType);
switch (keyType)
{
case KeyTypes.None:
wiFiKeyType = WiFiKeyType.None;
break;
case KeyTypes.NetworkKey:
wiFiKeyType = WiFiKeyType.NetworkKey;
break;
case KeyTypes.PassPhrase:
wiFiKeyType = WiFiKeyType.PassPhrase;
break;
}
return(wiFiKeyType);
}
/// <summary>
/// Loads a key from KeyChangerConfig.json.
/// </summary>
/// <param name="type">The type of key to load.</param>
/// <returns>The key with all the required data.</returns>
public static Key LoadKey(KeyTypes type)
{
Key key;
switch (type)
{
case KeyTypes.Temple:
key = new Key("temple", KeyTypes.Temple, KeyChanger.Config.EnableTempleKey);
key.Items = GetItems(KeyChanger.Config.TempleKeyItem);
key.Region = TShock.Regions.GetRegionByName(KeyChanger.Config.TempleRegion);
break;
case KeyTypes.Jungle:
key = new Key("jungle", KeyTypes.Jungle, KeyChanger.Config.EnableJungleKey);
key.Items = GetItems(KeyChanger.Config.JungleKeyItem);
key.Region = TShock.Regions.GetRegionByName(KeyChanger.Config.JungleRegion);
break;
case KeyTypes.Corruption:
key = new Key("corruption", KeyTypes.Corruption, KeyChanger.Config.EnableCorruptionKey);
key.Items = GetItems(KeyChanger.Config.CorruptionKeyItem);
key.Region = TShock.Regions.GetRegionByName(KeyChanger.Config.CorruptionRegion);
break;
case KeyTypes.Crimson:
key = new Key("crimson", KeyTypes.Crimson, KeyChanger.Config.EnableCrimsonKey);
key.Items = GetItems(KeyChanger.Config.CrimsonKeyItem);
key.Region = TShock.Regions.GetRegionByName(KeyChanger.Config.CrimsonRegion);
break;
case KeyTypes.Hallowed:
key = new Key("hallowed", KeyTypes.Hallowed, KeyChanger.Config.EnableHallowedKey);
key.Items = GetItems(KeyChanger.Config.HallowedKeyItem);
key.Region = TShock.Regions.GetRegionByName(KeyChanger.Config.HallowedRegion);
break;
case KeyTypes.Frozen:
key = new Key("frozen", KeyTypes.Frozen, KeyChanger.Config.EnableFrozenKey);
key.Items = GetItems(KeyChanger.Config.FrozenKeyItem);
key.Region = TShock.Regions.GetRegionByName(KeyChanger.Config.FrozenRegion);
break;
default:
return null;
}
return key;
}
public string Generate(int length, KeyTypes keyType = KeyTypes.Mixed)
{
var random = new Random();
var tempPassword = new List <char>(length);
var valueVarint = 0;
for (var index = 0; index < tempPassword.Count; index++)
{
switch (keyType)
{
case KeyTypes.Mixed:
valueVarint = random.Next(3);
break;
case KeyTypes.Digits:
valueVarint = 0;
break;
case KeyTypes.Letters:
valueVarint = random.Next(2) + 1;
break;
}
switch (valueVarint)
{
case 0:
tempPassword[index] = (char)(random.Next(10) + 48);
break;
case 1:
tempPassword[index] = (char)(random.Next(26) + 65);
break;
case 2:
tempPassword[index] = (char)(random.Next(26) + 97);
break;
}
}
return(new string(tempPassword.ToArray()));
}
/// <summary>
/// Creates a new <see cref="GeneralKeyHeader"/> with the
/// <paramref name="keyType"/>, <paramref name="bitLength"/>
/// and <paramref name="exponent"/> provided.
/// </summary>
/// <param name="keyType">The <see cref="KeyTypes"/> value which determines
/// whether the <see cref="GeneralKeyHeader"/> is for a public or a private
/// key.</param>
/// <param name="bitLength">The <see cref="UInt32"/> which determines the number of bits
/// used to construct the cryptographic key used by the algorithm.</param>
/// <param name="exponent">The <see cref="UInt32"/> value denoting the public exponent of the
/// current key pair.</param>
public GeneralKeyHeader(KeyTypes keyType, uint bitLength, uint exponent)
{
switch (keyType)
{
case KeyTypes.PublicKey:
this.keyTypeId = KeyIdentifiers.PublicKey;
break;
case KeyTypes.PrivateKey:
this.keyTypeId = KeyIdentifiers.PrivateKey;
break;
default:
this.keyTypeId = KeyIdentifiers.None;
break;
}
this.keyType = keyType;
this.bitLength = bitLength;
this.version = StrongNameVersion;
this.reserved = 0;
this.algorithmId = RSASigningAlgorithmId;
this.exponent = exponent;
}
public Key(KeyTypes keyType, int keyMidiId, double centrePosition)
{
KeyType = keyType;
KeyMidiId = keyMidiId;
centreXPosition = centrePosition;
Stroke = Brushes.Black;
SetDefaultKeyColour();
MouseEnter += (o, e) =>
{
SetKeyPressedColour();
};
MouseLeave += (o, e) =>
{
SetDefaultKeyColour();
};
MouseDown += HandleKeyDown;
MouseUp += HandleKeyUp;
//When mouse leaves key region, throw a key upevent just incase.
MouseLeave += HandleKeyUp;
}
private void AddKeyToDictionary(int keyId, KeyTypes keyType, double keyWidth)
{
Key key = new Key(keyType, keyId, keyWidth);
Keys.Add(keyId, key);
}
public KeyPair(KeyTypes type, string privatePem, string publicPem)
{
Type = type;
PrivatePem = privatePem;
PublicPem = publicPem;
}
/// <summary>
/// Retrieves the keys marked with the usage given as parameter.
/// </summary>
/// <returns>A list containing the keys. If no key is marked with the given usage, the method returns an empty list.</returns>
public List<KeyDescriptor> GetKeys(KeyTypes usage)
{
return Keys.FindAll(delegate(KeyDescriptor desc) { return desc.use == usage; });
}
public PianoKey(KeyTypes keyType, short octave)
{
KeyType = keyType;
Octave = octave;
Geometry = GenerateGeometry();
}
/// <summary>
/// Retrieves the keys marked with the usage given as parameter.
/// </summary>
/// <param name="usage">The usage.</param>
/// <returns>A list containing the keys. If no key is marked with the given usage, the method returns an empty list.</returns>
public List<KeyDescriptor> GetKeys(KeyTypes usage)
{
return Keys.FindAll(desc => desc.Use == usage);
}
/// <summary>
/// Получение длины ключа для типа ключа
/// </summary>
/// <param name="type">Тип ключа</param>
/// <returns>Возвращает длину ключа</returns>
private static int GetKeyLenForType(KeyTypes type)
{
int res = 0;
switch (type)
{
case KeyTypes.SHA1:
res = 128;
break;
case KeyTypes.AES:
res = 64;
break;
case KeyTypes.DES3:
res = 48;
break;
}
return res;
}
/// <summary>
/// Получение строки с названием уку
/// </summary>
/// <param name="type">Тип ключа (алгоритм)</param>
/// <returns>Возвращает строку с названием алгоритма для файла конфигурации</returns>
private static string GetAlgorithmName(KeyTypes type)
{
string str = "";
switch (type)
{
case KeyTypes.AES:
str = type.ToString();
break;
case KeyTypes.SHA1:
str = type.ToString();
break;
case KeyTypes.DES3:
str = "3DES";
break;
}
return str;
}
/// <summary>
/// Генерация случайного ключа для приложения
/// </summary>
/// <param name="type">Тип ключа</param>
/// <returns>Возвращает данные ключа и сам ключ</returns>
public static KeyData GenerateKey(KeyTypes type)
{
int len = GetKeyLenForType(type);
byte[] buff = new byte[len / 2];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetBytes(buff);
StringBuilder sb = new StringBuilder(len);
for (int i = 0; i < buff.Length; i++)
sb.Append(string.Format("{0:X2}", buff[i]));
KeyData res = new KeyData();
res.KeyValue = sb.ToString();
res.Length = len;
res.Type = type;
return res;
}
