public void DecryptRsaNoKeyFound()
{
var asc = @"-----BEGIN PGP MESSAGE-----
Version: GnuPG v1.4.13 (MingW32)
hQEMA2si+TwJAdWiAQgAmbzqGlG1+Kykb8BaoqEThxxxJgyyW1TdskmiQXWGOhbx
8L6jAHloQjcYHPkQvsUY+fXZtvZVQEsuH+/XIWgB1Z7WEM2I+koJa20NyoF5SLFo
J+rhWRqth/BkmbzH+lx2UssENBDTrskWzm+9SXrw1B3NH+AzB5mVAvvVnIEbG/mY
w4mxV9lea2LeVMskHxoXnvXJtzpH9niTBDlN8hrNB0HaX8IK1fZ2z1Np7ckQ8Osv
mHDyWc8nzIjPecgeVVriZ4RcExAlVxgAdoEG1wgBUj6LlsVIuQ3moD52pI8P61xf
ysPatezVC6RE5A1JOVrjRMOF1jCxqS2b8BfcVmXsCNJ+AYSYCD1NPJAv4/y3UmIm
9X/V8ZiaAurFpH5Vc0tEBR9vaiD8IEawoSeu/ALXnVzq7tCAozxKfL1TM7d1kRG0
9kKUcstxJ14D44fDjfRDhkw2nZqp60ZYm7WkM1E8CmFMGx7HyXg9q/mhew5F/hfV
fby+XTLHp2GRtgsSJUdb
=y/8S
-----END PGP MESSAGE-----
";
var context = new CryptoContext(GetPasswordCallback, Pubring, Secring, "rsa", "sha-1");
var crypto = new PgpCrypto(context);
try
{
crypto.DecryptAndVerify(Encoding.UTF8.GetBytes(asc));
}
catch (SecretKeyNotFoundException)
{
return;
}
Assert.True(false);
}
public void DecryptHiddenRecipientRsaNoKeyFound()
{
var asc = @"-----BEGIN PGP MESSAGE-----
Version: GnuPG v1.4.13 (MingW32)
hQEMAwAAAAAAAAAAAQgArP3V+DuoFP20hrZAAsX4+Uiiv1F4MG36dXzUcUFPFLjG
dyXC0D9mbSzt2FFGzgxMsJUf3vv1vhA6bPgmAlOKX+GVLOAdO3Tm7gt1p3i0fWvL
D0q3YVnq2U2Uiq3D5oy79bH1fjKT0lygruSipD9rntN7ZcGbzh7oaug3uyjAGm6K
Z9LbPJihdb84l4EfDnowzO3Nr5Tuxmz/e982fXEVHumozMJqEQz7dTovOBR3WovI
+Sj1uDfshPTr1xxmCxvNW70/3w0TC9Uo6RbG/LatO0vjUWrelic3SStxz+FNrEJz
KDBrN+Btdi7/RoiZaGrn7SFT6mRz68XJaz7iFTWXaNJ+ATmUzo0EJ4DmGqCFlzu5
8KqAf1fiTgW5eKOa1gAlbPvqMlUc85+8/P8xuzvLpQgHPSCWK0+lDXwaxcVwfs0l
XzDCLj3rHgbG9CcLlYG1fL0nkTg9G0sKCF+mldRO/H+2qWyy9/ce/O7OfVuVb0iv
9vyYxzh8E7P/4aqjnbWE
=m8iN
-----END PGP MESSAGE-----
";
var context = new CryptoContext(GetPasswordCallback, Pubring, Secring, "rsa", "sha-1");
var crypto = new PgpCrypto(context);
try
{
crypto.DecryptAndVerify(Encoding.UTF8.GetBytes(asc));
}
catch (SecretKeyNotFoundException)
{
return;
}
Assert.True(false);
}
public void DecryptAndVerifyRsa()
{
var asc = @"-----BEGIN PGP MESSAGE-----
Version: GnuPG v1.4.13 (MingW32)
hQEMA++lDjl5SynZAQf9EJhlb+wtv2/uagrx9TQwlj8PVewiY42F2+xVI6CWGqWH
2nraSkrEf4WXebZhVFmJUjK8f1MkqoRSBnUuGw3QzE5SkI4l13qvebqrZT2P1eTF
VesWuV0Fgy4qI0LHQs99q/SE0fAbYdsveiPucOwrNw1Wui77VFXQpklvJDG3PpZJ
zlL1842S83enQZ07gJHwFq6E/nm72be8wEIZAXtKFx1KIq0Is4JBVRIMymbljTWr
+V3bSRVhZvNVdNYgrQirH5zW6LZaloMHQhuvs2BWburgGBut5TxjmA93OwD0Le8r
Uc/ghOKEPa4GsIm5cNe+Iw5JNIUl/cjamrqULzc+YdLA8QGN2VCkm8upBIPR1Zpq
9T4EX+mhysUL31xedxki8mIh36DIdg5tu/2/6OggU5bm630Dv85YtstN40grN5oy
eUyhp/tnwWBs39ECGrIwgaNx5l9r3gD1UWZNg5rRd/wnIzCOHA7vVkfr9kEE0x1q
6voJxk/c4XBm3WMpXqSeuCpfLOzdaQFepWl0zymTogW2BGozbsVTMalHDOppXeWx
yikNljRB9NarZrnXLTvZXwRPlelO08/H7pq971RWYMl6vrzPK26/jwu6SYuLQS+B
4iazgNiJuoI2zc05cw8uq2G65cSJJj8bmHPJafr6BtGKjfkc+h4/OFt7zW9l1Be6
KeH+Q4pcdvjjejfuykzvDna+bIC4+Fq7PWairE0eaF9QAv+M2hKnoj34EdPbp1w1
pq+QloQyFU3v4mVrzaq6mTOqfDHsIIz41P401wTbRFnS19bGS3TObYd51MfDTftV
Jznp6f0w6cOYxlviTG0V0Q2QumCJ3WUZzDi4FyBLNn9bOX50Cb/1xFG+rlT/PBLY
DfLUSL37Hf3oOiLW1P1wTlJikWeIZfv4eSlaeAdIFCtML5g=
=oSWy
-----END PGP MESSAGE-----
";
var context = new CryptoContext(GetPasswordCallback, Pubring, Secring, "rsa", "sha-1");
var crypto = new PgpCrypto(context);
var clear = crypto.DecryptAndVerify(Encoding.UTF8.GetBytes(asc));
Assert.NotNull(clear);
Assert.AreEqual(File.ReadAllText(Path.Combine(Data, "msg1.bin")),
Encoding.UTF8.GetString(clear));
}
public void DecryptAndVerifyHiddenRecipientRsa()
{
var asc = @"-----BEGIN PGP MESSAGE-----
Version: GnuPG v1.4.13 (MingW32)
hQEMAwAAAAAAAAAAAQf+O/YreMkRPsjSlTKUjsELPkvLix7BeliDXvbpH/oCjf85
IP9uC5WQrCenvHiMkOYCYDqZ87BMTXvw5rjGZHhT73LVygJ8QXgpUCnFr6WJrv9D
58hoo5zXJVGJz4288nyi0iSMsTGsPPqCxT5nAEVBa/yuoJwAfHFC8vOGmneQgzuf
VaGFAVgNwSMx2jNrfipmQ9HPjZhyf8eVIQ4sO2K6uwNffsq1rkZp/ioQ1CTreIU2
OCmlJdZElM2RjkFlURGT5heXC8tUwclVAd3sDVfWQAGdXW2lpamIUgWdj7Sy48jn
wXnrW582QkHZNnzVcVq3x64TKUlbPl40SRaEchuhd9LA8QGeQ2ca8k5XX1acQj00
8wnZTm1m9DIe6ztqmemqTdOCopsV5HLRjBGMWTr8qi5bDH7mFJilRWrHQdro1izY
FJOD2ZLbAMYaYyUu1kEBhGYiaO1HLEyMjjFhnp+hULSE89a5tFs4Wk3ZvUqUoE2e
3GBxOVp5xaqCpDiYlf65PiSdKF9P1xmdmivFGqsSN1zuhUiXBIaUy3X65qLhpIT/
krfW/VTHMx/3pzdgrkFtOgNlauZ/9SOA6BvmYR433tR3KKJcdT76P9GJiOWaoAXd
RyF9w8r0V39qk0fVO1P3zK4CHnInLJlrMx41Ghsp5kKAhrUd4yIsbiUEHfNOpnqm
SpY248YkMC+gKMufTyH3AL7J4gCf8Xp1wIB5ZvsOECexlXBiID3vTKt2x3M6TAIJ
tOO+dpjwLi503izL2IStiPcGXqtdy7gG/Ca4jbcZXqh0bMz+ArOkfthazyjlLs3r
PgNIbeABQgWE+kOKZSMa6eqUMMa/JEak5AWTO3Rno0MPxZ5FXlsOljuuWx2J159M
3tFsO7a+UUM5fGH761PUA9PEx2lFsy6c4NGbI4ckYo+ACEI=
=W5+P
-----END PGP MESSAGE-----
";
var context = new CryptoContext(GetPasswordCallback, Pubring, Secring, "rsa", "sha-1");
var crypto = new PgpCrypto(context);
var clear = crypto.DecryptAndVerify(Encoding.UTF8.GetBytes(asc));
Assert.NotNull(clear);
Assert.AreEqual(File.ReadAllText(Path.Combine(Data, "msg1.bin")),
Encoding.UTF8.GetString(clear));
}
private SmartGlassClient(
Device device,
ConnectResponseMessage connectResponse,
CryptoContext cryptoContext)
{
Device = device;
_messageTransport = new MessageTransport(device.Address.ToString(), cryptoContext);
_sessionMessageTransport = new SessionMessageTransport(
_messageTransport,
new SessionInfo()
{
ParticipantId = connectResponse.ParticipantId
});
_sessionMessageTransport.MessageReceived += (s, e) =>
{
var consoleStatusMessage = e.Message as ConsoleStatusMessage;
if (consoleStatusMessage != null)
{
CurrentConsoleStatus = new ConsoleStatus()
{
Configuration = consoleStatusMessage.Configuration,
ActiveTitles = consoleStatusMessage.ActiveTitles
};
ConsoleStatusChanged?.Invoke(this, new ConsoleStatusChangedEventArgs(
CurrentConsoleStatus
));
}
};
_sessionMessageTransport.SendAsync(new LocalJoinMessage()).Wait();
OpenChannels().Wait();
_sessionMessageTransport.StartHeartbeat();
}
// Not working yet
//[Test]
public void ClearTextSignTest()
{
var context = new CryptoContext(
GetPasswordCallback,
@"C:\projects\OutlookPrivacyPlugin\Deja.Crypto.Test\pubring.gpg",
@"C:\projects\OutlookPrivacyPlugin\Deja.Crypto.Test\secring.gpg",
"rsa", "sha-1");
var crypto = new PgpCrypto(context);
var dataDir = @"C:\projects\OutlookPrivacyPlugin\Deja.Crypto.Test\data";
var signKey = "*****@*****.**";
var sign = string.Empty;
foreach (var file in Directory.EnumerateFiles(dataDir, "*.bin"))
{
Console.WriteLine("ClearTextSignTest: " + file);
context.Digest = "sha-1";
sign = crypto.SignClear(File.ReadAllText(file), signKey, Encoding.UTF8, new Dictionary <string, string>());
File.WriteAllText(@"c:\temp\test.bin", sign);
Assert.AreEqual(File.ReadAllText(file + ".rsa.sha1.clearsign"), sign);
context.Digest = "SHA-256";
sign = crypto.SignClear(File.ReadAllText(file), signKey, Encoding.UTF8, new Dictionary <string, string>());
Assert.AreEqual(File.ReadAllText(file + ".rsa.sha256.clearsign"), sign);
context.Digest = "SHA-1";
sign = crypto.Sign(File.ReadAllBytes(file), signKey, new Dictionary <string, string>());
File.WriteAllText(@"c:\temp\test.bin", sign);
Assert.AreEqual(File.ReadAllText(file + ".rsa.sha1.sign"), sign);
}
}
/// <summary>
/// CAUTION: YOU MUST <see langword="await"/> <see cref="_InitTask"/> BEFORE USING THIS OBJECT!
/// </summary>
/// <param name="device"></param>
/// <param name="connectResponse"></param>
/// <param name="cryptoContext"></param>
private SmartGlassClient(
Device device,
ConnectResponseMessage connectResponse,
CryptoContext cryptoContext, bool connectedAuthenticated)
{
this.connectedAuthenticated = connectedAuthenticated;
_messageTransport = new MessageTransport(device.Address.ToString(), cryptoContext);
_sessionMessageTransport = new SessionMessageTransport(
_messageTransport,
new SessionInfo()
{
ParticipantId = connectResponse.ParticipantId
});
_sessionMessageTransport.MessageReceived += (s, e) =>
{
var consoleStatusMessage = e.Message as ConsoleStatusMessage;
if (consoleStatusMessage != null)
{
CurrentConsoleStatus = new ConsoleStatus()
{
Configuration = consoleStatusMessage.Configuration,
ActiveTitles = consoleStatusMessage.ActiveTitles
};
ConsoleStatusChanged?.Invoke(this, new ConsoleStatusChangedEventArgs(
CurrentConsoleStatus
));
}
};
_InitTask = InitializeAsync();
}
public void DecryptRsa()
{
var asc = @"-----BEGIN PGP MESSAGE-----
Version: GnuPG v1.4.13 (MingW32)
hQEMA77VyJ6POr+OAQgAgdI5IJmGU7yy4HmT9KJ1ILyXLP7jYmCyXRIqfKYzJSVC
f1ftizgK+mcyhKSDkGWfG5iQrrujEWC49eYbRFdleHm7Nc1Vh1hrL3I4u+6pBMr+
DpgkUPdl0X1JT6DkD6szhuNHKSoubGCS4W4ix4ajLhjUd83AppdC0SZPDqEKB928
W5MN0GqCbKXexS5cJlvMpCzC+VgNRY+OHvP/QMYDWtiva6+hqcz6nXqOWGL5uSA6
hydPHzcdVr/U4oyIiy1d+U8mDBVf63fjDL0fyz5+1BwvCDajo53UaBBhm6x9Ypi0
gUUeoPAop6rwdLCOidJnkZ9urL0aVP8BGkuYpHu6MdJ/AcDyLO+SKpIZB/jagAYx
X9umSv/cUrgsWLW33XG1mrN1AnoPmGxnXonmjaSjGg+gx23iwfAoJ7FgbiQwsjEG
uZO20xfs+U01YMTTxUM7mjYVW0vbH48bTNxTmEKOF4ok5GBE/1ZUBWKjIM1gAo9Z
pc+96NTCnChekF7WxjbcVQ==
=ARyr
-----END PGP MESSAGE-----
";
var context = new CryptoContext(GetPasswordCallback, Pubring, Secring, "rsa", "sha-1");
var crypto = new PgpCrypto(context);
var clear = crypto.DecryptAndVerify(Encoding.UTF8.GetBytes(asc));
Assert.NotNull(clear);
Assert.AreEqual(File.ReadAllText(Path.Combine(Data, "msg1.bin")),
Encoding.UTF8.GetString(clear));
}
byte[] DecryptAndVerify(string to, byte[] data, out CryptoContext outContext)
{
_decryptAndVerifyHeaderMessage = "";
outContext = null;
if (!PromptForPasswordAndKey())
return null;
var context = new CryptoContext(Passphrase);
var crypto = new PgpCrypto(context);
try
{
var cleartext = crypto.DecryptAndVerify(data, _settings.IgnoreIntegrityCheck);
context = crypto.Context;
outContext = context;
return cleartext;
}
catch (Exception e)
{
Passphrase = null;
WriteErrorData("DecryptAndVerify", e);
ShowErrorBox(e.Message.ToLower().StartsWith("checksum") ? "Incorrect passphrase possibly entered." : e.Message);
}
return null;
}
private Signature VerifyClearSignature(ref CryptoContext context, PgpCrypto crypto, string clearsig)
{
var signature = new Signature();
try
{
var valid = crypto.VerifyClear(_encoding.GetBytes(clearsig));
context = crypto.Context;
signature.Valid = valid;
signature.KeyId = context.SignedByKeyId;
signature.UserId = context.SignedByUserId;
}
catch (PublicKeyNotFoundException ex)
{
Logger.Debug(ex.ToString());
return null;
}
catch (Exception ex)
{
Logger.Debug(ex.ToString());
Passphrase = null;
WriteErrorData("VerifyEmail", ex);
ShowErrorBox(ex.Message);
return null;
}
return signature;
}
private SmartGlassClient(
Device device,
ConnectResponseMessage connectResponse,
CryptoContext cryptoContext)
{
_messageTransport = new MessageTransport(device.Address.ToString(), cryptoContext);
_sessionMessageTransport = new SessionMessageTransport(
_messageTransport,
new SessionInfo()
{
ParticipantId = connectResponse.ParticipantId
});
_sessionMessageTransport.MessageReceived += (s, e) =>
{
var consoleStatusMessage = e.Message as ConsoleStatusMessage;
if (consoleStatusMessage != null)
{
ConsoleStatusChanged?.Invoke(this, new ConsoleStatusChangedEventArgs(
new ConsoleStatus()
{
Configuration = consoleStatusMessage.Configuration,
ActiveTitles = consoleStatusMessage.ActiveTitles
}
));
}
};
_sessionMessageTransport.SendAsync(new LocalJoinMessage());
_inputChannel = new DisposableAsyncLazy <InputChannel>(async() =>
{
return(new InputChannel(await StartChannelAsync(ServiceType.SystemInput)));
});
}
private static void RunSecureComputationParty(int startPort, int numberOfParties, int localPartyId, BitArray localInput, BitArray expectedOutput)
{
using (IMultiPartyNetworkSession session = TestNetworkSession.EstablishMultiParty(localPartyId, numberOfParties))
{
using (CryptoContext cryptoContext = CryptoContext.CreateDefault())
{
IObliviousTransfer obliviousTransfer = new NaorPinkasObliviousTransfer(
new SecurityParameters(47, 23, 4, 1, 1),
cryptoContext
);
IMultiplicativeSharing multiplicativeSharing = new ObliviousTransferMultiplicativeSharing(
obliviousTransfer,
cryptoContext
);
GMWSecureComputation computation = new GMWSecureComputation(session, multiplicativeSharing, cryptoContext);
SetIntersectionCircuitRecorder circuitRecorder = new SetIntersectionCircuitRecorder(numberOfParties, localInput.Length);
CircuitBuilder circuitBuilder = new CircuitBuilder();
circuitRecorder.Record(circuitBuilder);
ForwardCircuit circuit = new ForwardCircuit(circuitBuilder.CreateCircuit());
BitArray output = computation.EvaluateAsync(circuit, circuitRecorder.InputMapping, circuitRecorder.OutputMapping, localInput).Result;
CollectionAssert.AreEqual(
expectedOutput,
output,
"Incorrect output {0} (should be {1}).",
output.ToBinaryString(),
expectedOutput.ToBinaryString()
);
}
}
}
/// <summary>
/// CAUTION: YOU MUST <see langword="await"/> <see cref="_InitTask"/> BEFORE USING THIS OBJECT!
/// </summary>
/// <param name="device"></param>
/// <param name="connectResponse"></param>
/// <param name="cryptoContext"></param>
private SmartGlassClient(
Device device,
ConnectResponseMessage connectResponse,
CryptoContext cryptoContext)
{
_messageTransport = new MessageTransport(device.Address.ToString(), cryptoContext);
_sessionMessageTransport = new SessionMessageTransport(
_messageTransport,
new SessionInfo()
{
ParticipantId = connectResponse.ParticipantId
});
_sessionMessageTransport.ProtocolTimeoutOccured += (_, e) => ProtocolTimeoutOccured?.Invoke(this, e);
_sessionMessageTransport.MessageReceived += (s, e) =>
{
if (e.Message is ConsoleStatusMessage consoleStatusMessage)
{
CurrentConsoleStatus = new ConsoleStatus()
{
Configuration = consoleStatusMessage.Configuration,
ActiveTitles = consoleStatusMessage.ActiveTitles
};
ConsoleStatusChanged?.Invoke(this, new ConsoleStatusChangedEventArgs(
CurrentConsoleStatus
));
}
};
_InitTask = InitializeAsync();
}
private static void RunSecureComputationParty(int localPartyId, BitArray localInput)
{
using (IMultiPartyNetworkSession session = CreateLocalSession(localPartyId, StartPort, NumberOfParties))
{
using (CryptoContext cryptoContext = CryptoContext.CreateDefault())
{
IObliviousTransfer obliviousTransfer = new NaorPinkasObliviousTransfer(
SecurityParameters.CreateDefault768Bit(),
cryptoContext
);
IMultiplicativeSharing multiplicativeSharing = new ObliviousTransferMultiplicativeSharing(
obliviousTransfer,
cryptoContext
);
GMWSecureComputation computation = new GMWSecureComputation(session, multiplicativeSharing, cryptoContext);
Stopwatch stopwatch = Stopwatch.StartNew();
SetIntersectionSecureProgram secureProgram = new SetIntersectionSecureProgram(NumberOfParties, NumberOfElements);
object[] outputPrimitives = secureProgram.EvaluateAsync(computation, new[] { localInput }).Result;
BitArray intersection = (BitArray)outputPrimitives[0];
BigInteger count = (BigInteger)outputPrimitives[1];
stopwatch.Stop();
Console.WriteLine();
Console.WriteLine("Completed protocol as {0} in {1} ms.", session.LocalParty.Name, stopwatch.ElapsedMilliseconds);
Console.WriteLine(" Local input: {0}", localInput.ToBinaryString());
Console.WriteLine(" Computed intersection: {0}", intersection.ToBinaryString());
Console.WriteLine(" Computed number of matches: {0}", count);
}
}
}
public void UnicodeUtf8PageTest()
{
var clear = @"Hi Meddington,
i think i have found the issue.
I write this mail as - only text - message.
If another receive this email, my signature email and webaddress are i
nterpreted as links and will be changed by outlook to html elements.
Mit freundlichen Grüßen,
Sebastian Lutz
Baebeca Solutions - Lutz
E-Mail: [email protected]
Tel. Büro: 02261 - 9202935
Tel. Mobil: 0171 - 6431821
Web: https://www.baebeca.de
PGP Key: 0x5AD0240C
";
var context = new CryptoContext(GetPasswordCallback, Pubring, Secring, "rsa", "sha-1");
var crypto = new PgpCrypto(context);
var clearSig = crypto.SignClear(clear, "*****@*****.**", Encoding.UTF8, new Dictionary <string, string>());
var ret = crypto.VerifyClear(Encoding.UTF8.GetBytes(clearSig));
Assert.IsTrue(ret);
}
public void DecryptHiddenRecipient()
{
var asc = @"-----BEGIN PGP MESSAGE-----
Version: GnuPG v1.4.13 (MingW32)
hQEMAwAAAAAAAAAAAQgAjccvC3wJSL/FDp0yBkq3ktYHzFDk31whvAG6JX2ZoJzP
4bqkPxEOYKFur+ioxHN1TKrwRMQsjAHrfsBVkWxFNx/UqDeZSGGlreRPcn/Vv83x
Cs8J/5OaE/8iVzXSplENPI8o7Ahb8+7ewllJdmzr6E0gOl5VCUoFTTLq8rkzXg6c
VzdFC71QMr0x+Ef37zJwxkBsRWOBq6Kdwa7o5DXeyVJ54QsBwJJXesF3zKKmjE8y
8kdzLJqbK78yzmif0fa/IVizf+rQTYhiFuqGdnKjIpNr5YVbLofTgDveNSTB7XOg
Yw5/Va1VG6Om1puPeVBAXwr3ZVwZehG4H5xL2dhFONJ+AejHz6CeT8Fz1badKW92
VFL2bm1FZYHwjZjwIGXMR1CAbE/rQs+iS9b2bNLWPOAg/FB5zcUQ6Cc7IkH4hd3H
4PWtXsmwqLB1kKl+DYvy16rCvFPhvHdJO0Z3z/yn5520yx+TQ0brUWGUEkF0WbMR
3ioXxFhpcXhmPmTYqctK
=s0gQ
-----END PGP MESSAGE-----
";
var context = new CryptoContext(GetPasswordCallback, Pubring, Secring, "rsa", "sha-1");
var crypto = new PgpCrypto(context);
var clear = crypto.DecryptAndVerify(Encoding.UTF8.GetBytes(asc));
Assert.NotNull(clear);
Assert.AreEqual(File.ReadAllText(Path.Combine(Data, "msg1.bin")),
Encoding.UTF8.GetString(clear));
}
public void DecryptAndVerifyCryptix()
{
var asc = @"-----BEGIN PGP MESSAGE-----
Version: Cryptix OpenPGP 0.20050418
hIwDblSySC/BGaQBBACXq8hOXnGCsCrBt3YU3XgxR+KBrwNh5U/hseMODMY+Gg+w
jHARa7h9r7ekw+UEw3e2CJzoI0TL1LYM7o3N79mBqUJMIRjyV+dFaE8/it+Xphv3
+B+DyyrlO7Y013MM9v8o7UF5wJyxyIMedeodfboVYOuEYZGMOCZNeP9WgbZIa6Tv
qC+dKk++UQH1nAq7PWl2hrXHl3wWK/kZ+O/bGMFDEpbDL2PenLEy47kvQT4fGRZT
iB+O4gP38rpoPF/s1agFtwfNkWHBGlwHOqBpjuT1ya56aPfkDsNGTW0/Jp+dnTIH
YYGwwCEOQLJemt5ELK8+BZEMRi/5zCmxF/4z9yRUP6IqrotQMWuxjm2d8Z4QhecK
j/nOOPQyDT/WQLFFOI4whGy9D8QHkXNrqsGHY1YORN3s8Di0+ARkSFtRMhjEgzA0
+U+RVtsnaH4pw8pzbHEpZS9Znt75ep+Vune/cyiPfJuvw5uQlns9bLAtHKtt9NY=
=uF5e
-----END PGP MESSAGE-----
";
var context = new CryptoContext(GetPasswordCallback, Pubring, Secring, "rsa", "sha-1");
var crypto = new PgpCrypto(context);
var clear = crypto.DecryptAndVerify(Encoding.UTF8.GetBytes(asc), true);
Assert.NotNull(clear);
Assert.AreEqual("This is a test message.\r\nThis is another line.\r\n",
Encoding.UTF8.GetString(clear));
}
public HangfireJobs(CryptoContext context, ILogger <HangfireJobs> logger, ILogger <EmailSender> emailLogger, IConfiguration configuration)
{
_context = context;
_logger = logger;
_emailLogger = emailLogger;
_configuration = configuration;
_apiKey = @"&api_key=" + configuration.GetSection("Cryptocompare.com")["ApiKey"];
}
public MessageTransport(string addressOrHostname, CryptoContext crypto)
{
_addressOrHostname = addressOrHostname;
_crypto = crypto;
_client = _addressOrHostname != null ?
new UdpClient(_addressOrHostname, 5050) :
new UdpClient(AddressFamily.InterNetwork);
if (_addressOrHostname == null)
{
_client.Client.Bind(new IPEndPoint(IPAddress.Any, 0));
}
_cancellationTokenSource = _client.ConsumeReceived(receiveResult =>
{
var reader = new BEReader(receiveResult.Buffer);
var messageType = (MessageType)reader.ReadUInt16();
reader.Position = 0;
var message = CreateFromMessageType(messageType);
if (message == null)
{
// TODO: Tracing for this.
return;
}
var cryptoMessage = message as ICryptoMessage;
if (cryptoMessage != null)
{
cryptoMessage.Crypto = _crypto;
}
message.Origin = receiveResult.RemoteEndPoint;
message.ClientReceivedTimestamp = DateTime.Now;
message.Deserialize(reader);
_receiveQueue.TryAdd(message);
});
Task.Run(() =>
{
while (!_receiveQueue.IsCompleted)
{
try
{
var message = _receiveQueue.Take();
MessageReceived?.Invoke(this, new MessageReceivedEventArgs <IMessage>(message));
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Console.WriteLine("Calling MessageReceived failed!");
}
}
});
}
public ObliviousTransferPreprocessor(IObliviousTransfer obliviousTransfer, CryptoContext cryptoContext)
{
if (obliviousTransfer == null)
{
throw new ArgumentNullException(nameof(obliviousTransfer));
}
_obliviousTransfer = obliviousTransfer;
_randomNumberGenerator = new ThreadsafeRandomNumberGenerator(cryptoContext.RandomNumberGenerator);
}
public void TestCryptoSetup()
{
byte[] cert = ResourcesProvider.GetBytes("selfsigned_cert.bin", ResourceType.Misc);
var x509 = CryptoExtensions.DeserializeCertificateAsn(cert);
CryptoContext context = new CryptoContext(x509);
Assert.NotNull(context);
Assert.Equal <PublicKeyType>(PublicKeyType.EC_DH_P256, context.PublicKeyType);
}
protected void Dispose(bool disposing)
{
if (disposing)
{
if (db != null)
{
db.Dispose();
db = null;
}
}
}
public AuthController(CryptoContext context,
SignInManager <CryptoUser> signInMgr,
UserManager <CryptoUser> userMgr,
IPasswordHasher <CryptoUser> hasher,
ConfigSettings configSettings, RoleManager <IdentityRole> roleMgr)
{
_context = context;
_userMgr = userMgr;
_hasher = hasher;
_configSettings = configSettings;
_roleMgr = roleMgr;
}
private void RunObliviousTransferParty1oo2Resumed()
{
const int numberOfInvocations = 3;
const int numberOfOptions = 2;
Pair <byte[]>[] options = new Pair <byte[]> [numberOfInvocations];
options = new Pair <byte[]>[]
{
new Pair <byte[]>(TestOptions.Take(numberOfOptions).Select(s => Encoding.ASCII.GetBytes(s)).ToArray()),
new Pair <byte[]>(TestOptions.Take(numberOfOptions).Select(s => Encoding.ASCII.GetBytes(s.ToLower())).ToArray()),
new Pair <byte[]>(TestOptions.Take(numberOfOptions).Select(s => Encoding.ASCII.GetBytes(s.ToUpper())).ToArray()),
};
using (CryptoContext cryptoContext = CryptoContext.CreateDefault())
{
using (ITwoPartyNetworkSession session = TestNetworkSession.EstablishTwoParty())
{
ITwoChoicesObliviousTransferChannel baseOT = new StatelessTwoChoicesObliviousTransferChannel(new InsecureObliviousTransfer(), session.Channel);
ITwoChoicesObliviousTransferChannel obliviousTransfer = new TwoChoicesExtendedObliviousTransferChannel(baseOT, 8, cryptoContext);
if (session.LocalParty.Id == 0)
{
for (int i = 0; i < 2; ++i)
{
obliviousTransfer.SendAsync(options, numberOfInvocations, 6).Wait();
}
}
else
{
PairIndexArray[] allIndices = new[] { new PairIndexArray(new[] { 0, 1, 0 }), new PairIndexArray(new[] { 1, 0, 0 }) };
for (int i = 0; i < 2; ++i)
{
PairIndexArray indices = allIndices[i];
byte[][] results = obliviousTransfer.ReceiveAsync(indices, numberOfInvocations, 6).Result;
Assert.IsNotNull(results, "Result is null.");
Assert.AreEqual(numberOfInvocations, results.Length, "Result does not match the correct number of invocations.");
for (int j = 0; j < numberOfInvocations; ++j)
{
CollectionAssert.AreEqual(
results[j],
options[j][indices[j]],
"Incorrect message content {0} (should be {1}).",
Encoding.ASCII.GetString(results[j]),
Encoding.ASCII.GetString(options[j][indices[j]])
);
}
}
}
}
}
}
private byte[][] RunObliviousTransferReceiverParty(BitArray selectionBits)
{
using (CryptoContext cryptoContext = CryptoContext.CreateDefault())
{
using (var session = TestNetworkSession.EstablishTwoParty())
{
ITwoChoicesObliviousTransferChannel baseOT = new StatelessTwoChoicesObliviousTransferChannel(new InsecureObliviousTransfer(), session.Channel);
ITwoChoicesCorrelatedObliviousTransferChannel obliviousTransfer = new TwoChoicesCorrelatedExtendedObliviousTransferChannel(baseOT, 8, cryptoContext);
return(obliviousTransfer.ReceiveAsync(selectionBits, selectionBits.Length, NumberOfMessageBytes).Result);
}
}
}
private Pair <byte[]>[] RunObliviousTransferSenderParty(int numberOfInvocations)
{
using (CryptoContext cryptoContext = CryptoContext.CreateDefault())
{
using (ITwoPartyNetworkSession session = TestNetworkSession.EstablishTwoParty())
{
ITwoChoicesObliviousTransferChannel baseOT = new StatelessTwoChoicesObliviousTransferChannel(new InsecureObliviousTransfer(), session.Channel);
ITwoChoicesRandomObliviousTransferChannel obliviousTransfer = new TwoChoicesRandomExtendedObliviousTransferChannel(baseOT, 8, cryptoContext);
return(obliviousTransfer.SendAsync(numberOfInvocations, NumberOfMessageBytes).Result);
}
}
}
public void CorrectEncryptKeyTest()
{
var context = new CryptoContext(
GetPasswordCallback,
@"C:\projects\OutlookPrivacyPlugin\Deja.Crypto.Test\pubring.gpg",
@"C:\projects\OutlookPrivacyPlugin\Deja.Crypto.Test\secring.gpg",
"rsa", "sha-1");
var crypto = new PgpCrypto(context);
var key = crypto.GetSecretKeyForEncryption("*****@*****.**");
Assert.AreEqual(long.Parse("BED5C89E8F3ABF8E", NumberStyles.HexNumber), key.KeyId);
}
public void TestInvoke()
{
using CryptoContext cryptoContext = CryptoContext.CreateDefault();
RandomOracle oracle = new HashRandomOracle(cryptoContext.HashAlgorithmProvider);
byte[] firstQuery = { 235, 12, 13, 72, 138, 13, 62, 13, 39, 147, 198, 173, 23, 87, 27, 99 };
byte[] secondQuery = { 84, 23, 123, 85, 62, 28, 54, 98, 187, 238, 18, 5, 78, 1, 78, 243 };
EnumerableAssert.AreNotEqual(
oracle.Invoke(secondQuery).Take(10),
oracle.Invoke(firstQuery).Take(10)
);
}
private Pair <byte[]>[] RunObliviousTransferSenderParty(byte[][] correlationStrings)
{
using (CryptoContext cryptoContext = CryptoContext.CreateDefault())
{
using (var session = TestNetworkSession.EstablishTwoParty())
{
ITwoChoicesObliviousTransferChannel baseOT = new StatelessTwoChoicesObliviousTransferChannel(new InsecureObliviousTransfer(), session.Channel);
ITwoChoicesCorrelatedObliviousTransferChannel obliviousTransfer = new TwoChoicesCorrelatedExtendedObliviousTransferChannel(baseOT, 8, cryptoContext);
return(obliviousTransfer.SendAsync(
correlationStrings, correlationStrings.Length, NumberOfMessageBytes).Result);
}
}
}
public NaorPinkasObliviousTransfer(SecurityParameters parameters, CryptoContext cryptoContext)
{
_parameters = parameters;
_randomOracle = new HashRandomOracle(cryptoContext.HashAlgorithmProvider.CreateThreadsafe());
_randomNumberGenerator = new ThreadsafeRandomNumberGenerator(cryptoContext.RandomNumberGenerator);
#if DEBUG
Console.WriteLine("Security parameters:");
Console.WriteLine("p = {0}", _parameters.P);
Console.WriteLine("q = {0}", _parameters.Q);
Console.WriteLine("g = {0}", _parameters.G);
Console.WriteLine("group element size = {0} bytes", _parameters.GroupElementSize);
Console.WriteLine("exponent size = {0} bytes", _parameters.ExponentSize);
#endif
}
