/// <summary>
/// The function Exchange sends a command APDU to a smart card and returns the response ADPU from the card.
/// </summary>
/// <param name="cmdApdu">Hexadecimal string containing the command APDU.</param>
/// <param name="expectedSW1SW2">The expected status word SW1SW2.</param>
/// <returns></returns>
public RespApdu Exchange(string cmdApdu, ushort?expectedSW1SW2)
{
byte[] responseBuffer = this.Exchange(HexEncoding.GetBytes(cmdApdu), expectedSW1SW2);
RespApdu respApdu = new RespApdu(responseBuffer);
return(respApdu);
}
private byte[] BuildSelectRcpPacket()
{
ByteBuilder bb = new ByteBuilder();
int discard;
byte[] param = new byte[7];
param[0] = (byte)
((comboBoxSelTarget.SelectedIndex << 5)
+ (comboBoxSelAction.SelectedIndex << 2)
+ (comboBoxSelMemBank.SelectedIndex));
param[1] = 0;
param[2] = 0;
param[3] = (byte)((Convert.ToUInt16(tbSelPointer.Text, 16) & 0xFF00) >> 8);
param[4] = (byte)((Convert.ToUInt16(tbSelPointer.Text, 16) & 0x00FF));
param[5] = byte.Parse(tbSelLength.Text);
param[6] = 0;
bb.Append(param);
byte[] mask = HexEncoding.GetBytes(tbSelMask.Text, out discard);
Array.Resize(ref mask, ((param[5] + 7) / 8));
if (mask.Length > 0)
{
bb.Append(mask);
}
return(bb.GetByteArray());
}
/// <summary>
///
/// </summary>
/// <param name="str"></param>
/// <param name="encoding"></param>
/// <param name="dataMode"></param>
/// <returns></returns>
protected byte[] StringToBytes(string str, Encoding encoding, DataMode dataMode)
{
if (encoding == null)
{
encoding = Encoding.UTF8;
}
byte[] byteArray = new byte[0];
switch (dataMode)
{
case DataMode.Plain:
byteArray = encoding.GetBytes(str);
break;
case DataMode.Hex:
byteArray = HexEncoding.GetBytes(str);
break;
case DataMode.Base64:
byteArray = Convert.FromBase64String(str);
break;
}
return(byteArray);
}
// costruttore aggiunto temporaneamente per eliminare il ricalcolo dell'hash della key ogni volta
public AncestorThread(Client client, string key)
{
thread = new Thread(Run);
this.client = client;
this.keyId = new PeerId();
keyId.Id = HexEncoding.GetBytes(key);
}
public void WriteHexString(string HexString)
{
int _out;
byte[] _byte = HexEncoding.GetBytes(HexString, out _out);
WriteArray(_byte);
}
// TODO: Chiamare key il parametro non è un po' fuorviante?!
public static PeerId LoadFromString(string key)
{
PeerId id = new PeerId();
//int discarded;
id.buffer = HexEncoding.GetBytes(key);
return(id);
}
public static EncryptionKey CreateFromSerializedString(String serializedString)
{
EncryptionKey retValue = new EncryptionKey();
var splitted = serializedString.Split('|');
retValue.Key = HexEncoding.GetBytes(splitted[0]);
retValue.IV = HexEncoding.GetBytes(splitted[1]);
return retValue;
}
public void OddNumberOfHexDigitsShouldRoundTripWithLeadingZero()
{
var hex = "A12F5";
var bytes = HexEncoding.GetBytes(hex);
var hex2 = HexEncoding.GetString(bytes);
Assert.Equal("0" + hex.ToLower(), hex2.ToLower());
}
public void HexStringsShouldRoundTrip()
{
var hex = "0A12F5";
var bytes = HexEncoding.GetBytes(hex);
var hex2 = HexEncoding.GetString(bytes);
Assert.Equal(hex.ToLower(), hex2.ToLower());
}
public void NotCaseSensitive()
{
var hex = "0a12F5";
var expected = new byte[] { 10, 18, 245 };
var actual = HexEncoding.GetBytes(hex);
Assert.Equal(expected, actual);
}
public void LeadingAndTrailingWhiteSpaceIgnored()
{
var hex = " 0A12F5\t\r\n";
var expected = new byte[] { 10, 18, 245 };
var actual = HexEncoding.GetBytes(hex);
Assert.Equal(expected, actual);
}
public void EvenNumberOfHexDigitsCanBeConvertedToBytes()
{
var hex = "0A12F5";
var expected = new byte[] { 10, 18, 245 };
var actual = HexEncoding.GetBytes(hex);
Assert.Equal(expected, actual);
}
public void ByteArraysShouldRoundTrip()
{
var bytes = new byte[] { 10, 18, 245 };
var hex = HexEncoding.GetString(bytes);
var bytes2 = HexEncoding.GetBytes(hex);
Assert.Equal(bytes, bytes2);
}
private void protocol(string data)
{
try
{
string header = data.Substring(1, 2);
string body = data.Substring(2);
switch (header)
{
#region Crypto
case "AQ":
case "AP":
if (LemonEnvironment.cryptoActive)
{
return;
}
// Client key
LemonEnvironment.clientKey = body.Substring(5);
// Make sure we have the keys from the haxswf - otherwise we'll get a null ref
while (LemonEnvironment.decPublicKey == null || LemonEnvironment.encPublicKey == null)
{
;
}
// Send the client key
LemonEnvironment.mainWnd.SendClientKey();
Thread.Sleep(600);
// send our own key
data = "_R" + MikeUtils.encodeB64(LemonEnvironment.encPublicKey) + LemonEnvironment.encPublicKey;
data = "@" + MikeUtils.encodeB64(data) + data;
// Once again, make sure we've got a key to init decryption with
// otherwise we'll get a null ref
while (LemonEnvironment.sharedKeyDec == null)
{
;
}
LemonEnvironment.RC4D = new Crypto.MikeCrypto(HexEncoding.GetBytes(LemonEnvironment.sharedKeyDec), LemonEnvironment.padding2);
break;
#endregion
default:
break;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
server.Send(data);
}
public void GetBytes_AllLowerCaseHexChars()
{
for (byte testByte = 0; testByte < 0xff; testByte++)
{
var actual = HexEncoding.GetBytes(testByte.ToString("x2"));
Assert.AreEqual(1, actual.Length);
Assert.AreEqual(testByte, actual[0]);
}
}
/// <summary>
/// Gets the specified collection key.
/// </summary>
/// <param name="collectionKey">The collection key.</param>
/// <returns></returns>
public string Get(string collectionKey)
{
byte[] bytes = HexEncoding.GetBytes(collectionKey);
string encodedKey = System.Text.Encoding.Default.GetString(bytes);
//string decryptHexEncoded = _cryptographyService.Decrypt(collectionKey);
PersistentCollection collection = _persistentCollectionRepository.Get(encodedKey);
return(collection != null ? collection.Value : string.Empty);
}
/// <summary>
/// Key B for the sector. This needs to be set when setting the access conditions. Key could not be read from card
/// </summary>
///
public async Task SetKeyB(string Key)
{
int discarded;
Byte[] keyB = HexEncoding.GetBytes(Key, out discarded);
DataBlock db = await GetDataBlockInt(GetTrailerBlockIndex());
Array.Copy(keyB, 0, db.Data, 10, 6);
}
public void WriteHexString(string hexstring)
{
if (hexstring == null)
{
return;
}
int discarded;
WriteBytes(HexEncoding.GetBytes(hexstring, out discarded));
}
public void GetBytes_RandomBytes()
{
var expected = new byte[1000];
(new Random()).NextBytes(expected);
var hexString = BitConverter.ToString(expected).Replace("-", "");
var actual = HexEncoding.GetBytes(hexString);
CollectionAssert.AreEqual(expected, actual);
}
/// <summary>
/// Takes an encrypted key in the form of a string as input
/// and applies the DES encryption algorithm to produce an
/// unencrypted byte array
/// </summary>
/// <param name="strEncryptedKey">Encrypted security key</param>
/// <returns></returns>
// Revision History
// MM/DD/YY Who Version Issue# Description
// -------- --- ------- ------ -------------------------------------------
// 06/21/13 RCG 2.70.77 Copied from CENTRON_AMI
private byte[] DecryptHANKey(string strEncryptedKey)
{
int Discarded;
SecureDataStorage DataStorage = null;
DESCryptoServiceProvider Crypto = null;
MemoryStream EncryptedStream = null;
MemoryStream DecryptedStream = null;
string strDecryptedKey = null;
StreamReader sr = null;
try
{
DataStorage = new SecureDataStorage(SecureDataStorage.DEFAULT_LOCATION);
Crypto = new DESCryptoServiceProvider();
Crypto.Key = DataStorage.RetrieveSecureData(SecureDataStorage.ZIGBEE_KEY_ID);
Crypto.IV = DataStorage.RetrieveSecureData(SecureDataStorage.ZIGBEE_IV_ID);
byte[] EncryptedKey = HexEncoding.GetBytes(strEncryptedKey, out Discarded);
//Create a memory stream to the passed buffer.
EncryptedStream = new MemoryStream(EncryptedKey);
DecryptedStream = new MemoryStream();
Encryption.DecryptData(Crypto, EncryptedStream, DecryptedStream);
//We must rewind the stream
DecryptedStream.Position = 0;
// Create a StreamReader for reading the stream.
sr = new StreamReader(DecryptedStream);
// Read the stream as a string.
strDecryptedKey = sr.ReadLine();
}
finally
{
// Close the streams.
//Closing sr also closes DecryptedStream
if (null != sr)
{
sr.Close();
}
else
{
DecryptedStream.Close();
}
EncryptedStream.Close();
Crypto.Dispose();
}
//Transform the string into a byte array
return(HexEncoding.GetBytes(strDecryptedKey, out Discarded));
}
public void GetBytes_ShouldThrowArgumentNullException_WhenInputIsNotDivisibleByTwo(string value, bool throwsException)
{
if (throwsException)
{
Assert.Throws <ArgumentException>(() => HexEncoding.GetBytes(value));
}
else
{
Assert.IsType <byte[]>(HexEncoding.GetBytes(value));
}
}
private void button2_Click(object sender, EventArgs e)
{
if (this.annoy && this.openFileDialog1.get_FileName() != "")
{
try
{
FileStream fileStream = new FileStream(this.openFileDialog1.get_FileName(), 3, 3, 0);
if (this.sigentered)
{
byte[] signature = new byte[4];
byte[] array = new byte[4];
byte[] array2 = new byte[4];
int num;
// This var takes the sig entered by user and returns an array using HexEncoding class
signature = HexEncoding.GetBytes(this.siggy.get_Text(), out num);
// array2 is set equal to the array returned by the Magic function which does something w/ it?
array2 = this.Magic(signature);
// FS is set to 4 bytes before the end of the file
fileStream.Seek(fileStream.get_Length() - 4L, 0);
// Write array2 to last 4 bytes of the file
BinaryWriter binaryWriter = new BinaryWriter(fileStream);
binaryWriter.Write(array2);
// Pass FS in blocks of 4096 bytes to signMap function - which writes the signature
this.signMap(4096, fileStream);
// Re-read the signature from map
string text = HexEncoding.ToString(this.ReadSig(fileStream));
// Put signature in textbox
this.label3.set_Text("Map Signature: " + text);
// Read signature from map again?????????
array = this.ReadSig(fileStream);
// Goto last 4 bytes
fileStream.Seek(fileStream.get_Length() - 4L, 0);
BinaryWriter binaryWriter2 = new BinaryWriter(fileStream);
// Write sig to last 4 bytes
binaryWriter2.Write(this.Magic(array));
// XOr through again at 4096 bytes and write signature to 720
this.signMap(4096, fileStream);
// Re-re-read the freakin signature and set the label equal to it
array = this.ReadSig(fileStream);
text = HexEncoding.ToString(array);
this.label3.set_Text("Map Signature: " + text + " Complete!");
}
fileStream.Close();
}
catch (IOException ex)
{
MessageBox.Show(ex.get_Message(), "Error Accessing File");
}
}
}
public void GetBytesTest()
{
string hexString = string.Empty; // TODO: Initialize to an appropriate value
int discarded = 0; // TODO: Initialize to an appropriate value
int discardedExpected = 0; // TODO: Initialize to an appropriate value
byte[] expected = null; // TODO: Initialize to an appropriate value
byte[] actual;
actual = HexEncoding.GetBytes(hexString, out discarded);
Assert.AreEqual(discardedExpected, discarded);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
// TODO: CreateStoreResponse non serve proprio a niente??
public void CreateFindValueRequest(string key)
{
// Calcolo lunghezza dei dati
byte[] bkey = HexEncoding.GetBytes(key);
//byte[] bFakeKey = new byte[Settings.ID_LENGTH];
//Array.Copy(bkey, bFakeKey, bkey.Length);
CreateHeader(Header.EvolutionDHT, Settings.ID_LENGTH);
finalMessage[1] = (byte)Opcode.FindvalueRequest;
// Dati
//bFakeKey.CopyTo(finalMessage, 4);
bkey.CopyTo(finalMessage, 4);
}
public void GetBytes_ThrowsExceptionForAllInvalidCharacters()
{
for (ushort testChar = 0; testChar < ushort.MaxValue; testChar++)
{
var c = (char)testChar;
if (char.IsDigit(c) ||
c == 'A' || c == 'B' || c == 'C' || c == 'D' || c == 'E' || c == 'F' ||
c == 'a' || c == 'b' || c == 'c' || c == 'd' || c == 'e' || c == 'f')
{
continue; // skip valid chars
}
Assert.ThrowsException <FormatException>(() => HexEncoding.GetBytes("0" + new string(new char[] { c })));
}
}
public RSACryptoServiceProvider GetProvider()
{
RSACryptoServiceProvider retValue = new RSACryptoServiceProvider();
Byte[] cspBlob;
if (!String.IsNullOrEmpty(PrivateKey))
{
cspBlob = HexEncoding.GetBytes(PrivateKey);
}
else
{
cspBlob = HexEncoding.GetBytes(PublicKey);
}
retValue.ImportCspBlob(cspBlob);
return retValue;
}
public void CreateFindValueResponse(string key, string val)
{
// Calcolo lunghezza dei dati
byte[] bkey = HexEncoding.GetBytes(key);
//byte[] bFakeKey = new byte[Settings.ID_LENGTH];
//Array.Copy(bkey, bFakeKey, bkey.Length);
byte[] bval = UTF8Encoding.ASCII.GetBytes(val);
CreateHeader(Header.EvolutionDHT, Settings.ID_LENGTH + bval.Length);
finalMessage[1] = (byte)Opcode.FindvalueResponse;
// Dati
//bFakeKey.CopyTo(finalMessage, 4);
bkey.CopyTo(finalMessage, 4);
bval.CopyTo(finalMessage, Settings.ID_LENGTH + 4);
}
public static String Decrypt(Byte[] key, Byte[] iv, String data)
{
using (MemoryStream ms = new MemoryStream())
using (RijndaelManaged crypto = new RijndaelManaged())
{
Byte[] rawData = HexEncoding.GetBytes(data);
ICryptoTransform ct = crypto.CreateDecryptor(key, iv);
using (CryptoStream cs = new CryptoStream(ms, ct, CryptoStreamMode.Write))
{
cs.Write(rawData, 0, rawData.Length);
cs.Close();
}
return(Encoding.UTF8.GetString(ms.ToArray()));
}
}
/// <summary>
/// Gets the custom WZ IV from settings
/// </summary>
/// <returns></returns>
public byte[] GetCusomWzIVEncryption()
{
bool loaded = Load();
if (loaded)
{
string storedCustomEnc = ApplicationSettings.MapleVersion_EncryptionBytes;
byte[] bytes = HexEncoding.GetBytes(storedCustomEnc);
if (bytes.Length == 4)
{
return(bytes);
}
}
return(new byte[4]); // fallback with BMS
}
public static AsymmetricEncryptionKey CreateFromString(String key, Boolean containsPrivateKey)
{
var cspBlob = HexEncoding.GetBytes(key);
using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
{
rsa.ImportCspBlob(cspBlob);
var publicKey = BitConverter.ToString(rsa.ExportCspBlob(false)).Replace("-", "");
String privateKey = "";
if (containsPrivateKey)
{
privateKey = BitConverter.ToString(rsa.ExportCspBlob(true)).Replace("-", "");
}
return new AsymmetricEncryptionKey() {
PublicKey = publicKey,
PrivateKey = privateKey,
};
}
}