private IDigest GetShaDigest()
{
IDigest shaDigest = null;
if (_shaBits == 1)
{
shaDigest = new Sha1Digest();
}
else if (_shaBits == 3)
{
shaDigest = new Sha3Digest();
}
else if (_shaBits == 224)
{
shaDigest = new Sha224Digest();
}
else if (_shaBits == 256)
{
shaDigest = new Sha256Digest();
}
else if (_shaBits == 384)
{
shaDigest = new Sha384Digest();
}
else
{
shaDigest = new Sha512Digest();
}
return(shaDigest);
}
private void btnFirmaMasiva_Click(object sender, EventArgs e)
{
FolderBrowserDialog fbd = new FolderBrowserDialog();
DialogResult dresult = fbd.ShowDialog();
if (dresult == DialogResult.OK)
{
foreach (string file in Directory.GetFiles(fbd.SelectedPath))
{
FileInfo fInfo = new FileInfo(file);
AsymmetricKeyParameter akp = ReadPrivateKey(lblFirma.Text);
Sha1Digest dig = new Sha1Digest();
byte[] msgBytes = File.ReadAllBytes(file);
dig.BlockUpdate(msgBytes, 0, msgBytes.Length);
byte[] result = new byte[dig.GetDigestSize()];
dig.DoFinal(result, 0);
Org.BouncyCastle.Crypto.Signers.RsaDigestSigner signer = new Org.BouncyCastle.Crypto.Signers.RsaDigestSigner(dig);
signer.Init(true, akp);
signer.BlockUpdate(result, 0, result.Length);
byte[] sig = signer.GenerateSignature();
string signString = Convert.ToBase64String(sig);
string signPath = string.Format("{0}{1}", fInfo.FullName, "sgn");
File.WriteAllText(signPath, signString, System.Text.Encoding.UTF8);
}
MessageBox.Show("Firma finalizada.");
}
}
public byte[] getLoadFileDataHash(String hash, bool includeDebug)
{
try
{
GeneralDigest digester;
if (hash == "SHA-256")
{
digester = new Sha256Digest();
}
if (hash == "SHA-1")
{
digester = new Sha1Digest();
}
else
{
throw new Exception("Unknown hash algorithm");
}
byte[] retValue = new byte[digester.GetDigestSize()];
byte[] inpuVal = getRawCode(includeDebug);
digester.BlockUpdate(inpuVal, 0, inpuVal.Length);
digester.DoFinal(retValue, 0);
return(retValue);
}
catch (Exception e)
{
throw new Exception("Not possible", e);
}
}
public static SecureRandom GetInstance(
string algorithm)
{
// TODO Compared to JDK, we don't auto-seed if the client forgets - problem?
// TODO Support all digests more generally, by stripping PRNG and calling DigestUtilities?
IDigest digest = null;
switch (algorithm.ToUpper(CultureInfo.InvariantCulture))
{
case "SHA1PRNG":
digest = new Sha1Digest();
break;
case "SHA256PRNG":
digest = new Sha256Digest();
break;
}
if (digest != null)
{
return(new SecureRandom(new DigestRandomGenerator(digest)));
}
throw new ArgumentException("Unrecognised PRNG algorithm: " + algorithm, "algorithm");
}
private static byte[] GetDigestInByteArray(
FileInfo file,
CancellationToken cancellationToken)
{
using (var readStream = file.OpenRead())
{
var digest = new Sha1Digest();
var output = new byte[digest.GetDigestSize()];
var buffer = new byte[BufferSizeInByte];
int read;
while ((read = readStream.Read(
buffer,
0,
buffer.Length)) > 0)
{
cancellationToken.ThrowIfCancellationRequested();
digest.BlockUpdate(
buffer,
0,
read
);
}
digest.DoFinal(
output,
0
);
return(output);
}
}
public static bool DoVerifyDsaSha1(IEnumerable <BufLen> bufs, I2PSigningPublicKey key, I2PSignature signed)
{
if (!SupportedSignatureType(signed.Certificate.SignatureType))
{
throw new NotImplementedException();
}
var sha = new Sha1Digest();
foreach (var buf in bufs)
{
sha.BlockUpdate(buf.BaseArray, buf.BaseArrayOffset, buf.Length);
}
var hash = new byte[sha.GetDigestSize()];
sha.DoFinal(hash, 0);
var dsa = new Org.BouncyCastle.Crypto.Signers.DsaSigner();
var sigsize = signed.Certificate.SignatureLength;
var r = new BigInteger(1, signed.Sig.BaseArray, signed.Sig.BaseArrayOffset + 0, sigsize / 2);
var s = new BigInteger(1, signed.Sig.BaseArray, signed.Sig.BaseArrayOffset + sigsize / 2, sigsize / 2);
var dsaparams =
new DsaPublicKeyParameters(
key.ToBigInteger(),
new DsaParameters(
I2PConstants.DsaP,
I2PConstants.DsaQ,
I2PConstants.DsaG));
dsa.Init(false, dsaparams);
return(dsa.VerifySignature(hash, r, s));
}
internal override ISigner GetSigner()
{
IDigest digest;
if (Digest == Sha224Digest)
{
digest = new Sha224Digest();
}
else if (Digest == Sha256Digest)
{
digest = new Sha256Digest();
}
else if (Digest == Sha384Digest)
{
digest = new Sha384Digest();
}
else if (Digest == Sha512Digest)
{
digest = new Sha512Digest();
}
else if (Digest == Sha1Digest)
{
digest = new Sha1Digest();
}
else
{
throw new InvalidKeyTypeException(string.Format("Unknown digest type :{0}", Digest));
}
if (Padding == PssPadding)
{
return(new PssSigner(new RsaBlindedEngine(), digest));
}
throw new InvalidKeyTypeException(string.Format("Unknown padding type :{0}", Padding));
}
public byte[] GetHash(Version version)
{
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
byte[] handshakeHash;
if (version < DTLSRecord.Version1_2)
{
IDigest sha1 = new Sha1Digest(this._VerifyHandshakeSHA1);
IDigest md5 = new MD5Digest(this._VerifyHandshakeMD5);
handshakeHash = new byte[sha1.GetDigestSize() + md5.GetDigestSize()];
md5.DoFinal(handshakeHash, 0);
sha1.DoFinal(handshakeHash, md5.GetDigestSize());
}
else
{
IDigest hash = new Sha256Digest((Sha256Digest)this._VerifyHandshake);
handshakeHash = new byte[hash.GetDigestSize()];
hash.DoFinal(handshakeHash, 0);
}
return(handshakeHash);
}
/// <summary>
/// Calculate the restore code for an authenticator. This is taken from the last 10 bytes of a digest of the serial and secret key,
/// which is then specially encoded to alphanumerics.
/// </summary>
/// <returns>restore code for authenticator (always 10 chars)</returns>
protected string BuildRestoreCode()
{
// return if not set
if (string.IsNullOrEmpty(Serial) == true || SecretKey == null)
{
return(string.Empty);
}
// get byte array of serial
byte[] serialdata = Encoding.UTF8.GetBytes(Serial.ToUpper().Replace("-", string.Empty));
byte[] secretdata = SecretKey;
// combine serial data and secret data
byte[] combined = new byte[serialdata.Length + secretdata.Length];
Array.Copy(serialdata, 0, combined, 0, serialdata.Length);
Array.Copy(secretdata, 0, combined, serialdata.Length, secretdata.Length);
// create digest of combined data
IDigest digest = new Sha1Digest();
digest.BlockUpdate(combined, 0, combined.Length);
byte[] digestdata = new byte[digest.GetDigestSize()];
digest.DoFinal(digestdata, 0);
// take last 10 chars of hash and convert each byte to our encoded string that doesn't use I,L,O,S
StringBuilder code = new StringBuilder();
int startpos = digestdata.Length - 10;
for (int i = 0; i < 10; i++)
{
code.Append(ConvertRestoreCodeByteToChar(digestdata[startpos + i]));
}
return(code.ToString());
}
public override void PerformTest()
{
IDigest d = new Sha1Digest();
ShortenedDigest sd = new ShortenedDigest(new Sha1Digest(), 10);
if (sd.GetDigestSize() != 10)
{
Fail("size check wrong for SHA-1");
}
if (sd.GetByteLength() != d.GetByteLength())
{
Fail("byte length check wrong for SHA-1");
}
//
// check output fits
//
sd.DoFinal(new byte[10], 0);
d = new Sha512Digest();
sd = new ShortenedDigest(new Sha512Digest(), 20);
if (sd.GetDigestSize() != 20)
{
Fail("size check wrong for SHA-512");
}
if (sd.GetByteLength() != d.GetByteLength())
{
Fail("byte length check wrong for SHA-512");
}
//
// check output fits
//
sd.DoFinal(new byte[20], 0);
try
{
new ShortenedDigest(null, 20);
Fail("null parameter not caught");
}
catch (ArgumentException)
{
// expected
}
try
{
new ShortenedDigest(new Sha1Digest(), 50);
Fail("short digest not caught");
}
catch (ArgumentException)
{
// expected
}
}
private static string FromStream_BOUNCY(Stream stream)
{
int BUFFER_SIZE = 5 * 1024 * 1024;
byte[] buffer = new byte[BUFFER_SIZE];
int total_read = 0;
int num_read = 0;
Sha1Digest sha1 = new Sha1Digest();
while (0 < (num_read = stream.Read(buffer, 0, BUFFER_SIZE)))
{
total_read += num_read;
sha1.BlockUpdate(buffer, 0, num_read);
}
byte[] hash = new byte[sha1.GetDigestSize()];
sha1.DoFinal(hash, 0);
// Convert to string
StringBuilder buff = new StringBuilder();
foreach (byte hash_byte in hash)
{
buff.Append(String.Format("{0:X1}", hash_byte));
}
return(buff.ToString());
}
private static async Task <byte[]> GetDigestInByteArrayAsync(
FileInfo file,
CancellationToken cancellationToken)
{
using (var readStream = file.OpenRead())
{
var digest = new Sha1Digest();
var output = new byte[digest.GetDigestSize()];
var buffer = new byte[BufferSizeInByte];
int read;
while ((read = await readStream.ReadAsync(
buffer,
0,
buffer.Length,
cancellationToken).ConfigureAwait(false)) > 0)
{
cancellationToken.ThrowIfCancellationRequested();
digest.BlockUpdate(
buffer,
0,
read
);
}
digest.DoFinal(
output,
0
);
return(output);
}
}
/// <summary>
/// Returns implementation of specified digest algorithm
/// </summary>
/// <param name="algorithm">Digest algorithm</param>
/// <returns>Implementation of specified digest algorithm</returns>
private static IDigest GetHashGenerator(DigestAlgorithm algorithm)
{
IDigest digest;
switch (algorithm)
{
default:
throw new NotSupportedException("Unsupported hash algorithm");
case DigestAlgorithm.SHA1:
digest = new Sha1Digest();
break;
case DigestAlgorithm.SHA256:
digest = new Sha256Digest();
break;
case DigestAlgorithm.SHA384:
digest = new Sha384Digest();
break;
case DigestAlgorithm.SHA512:
digest = new Sha512Digest(); break;
}
return(digest);
}
internal byte[] GetNSec3Hash(NSec3HashAlgorithm algorithm, int iterations, byte[] salt)
{
IDigest digest;
switch (algorithm)
{
case NSec3HashAlgorithm.Sha1:
digest = new Sha1Digest();
break;
default:
throw new NotSupportedException();
}
byte[] buffer = new byte[Math.Max(MaximumRecordDataLength + 1, digest.GetDigestSize()) + salt.Length];
int length = 0;
DnsMessageBase.EncodeDomainName(buffer, 0, ref length, this, null, true);
for (int i = 0; i <= iterations; i++)
{
DnsMessageBase.EncodeByteArray(buffer, ref length, salt);
digest.BlockUpdate(buffer, 0, length);
digest.DoFinal(buffer, 0);
length = digest.GetDigestSize();
}
byte[] res = new byte[length];
Buffer.BlockCopy(buffer, 0, res, 0, length);
return(res);
}
public static string CreateAccept(string key)
{
var challenge = Encoding.ASCII.GetBytes(key + Consts.ServerMagicGuid);
var hash = Sha1Digest.ComputeHash(challenge);
var calculatedAccept = Convert.ToBase64String(hash);
return(calculatedAccept);
}
public static byte[] SHA1(byte[] data, int offset, int count)
{
var sha1 = new Sha1Digest();
sha1.BlockUpdate(data, offset, count);
byte[] rv = new byte[20];
sha1.DoFinal(rv, 0);
return(rv);
}
private byte[] ComputeHash(byte[] input)
{
var sha = new Sha1Digest();
sha.BlockUpdate(input, 0, input.Length);
byte[] result = new byte[sha.GetDigestSize()];
sha.DoFinal(result, 0);
return(result);
}
static byte[] Sha1(byte[] dat)
{
Sha1Digest digester = new Sha1Digest();
byte[] retValue = new byte[digester.GetDigestSize()];
digester.BlockUpdate(dat, 0, dat.Length);
digester.DoFinal(retValue, 0);
return(retValue);
}
private string ExecuteHash()
{
IDigest hash;
switch (this.HashFunctionComboBox.Text)
{
case "Blake2b - 256 bit":
hash = new Blake2bDigest(256);
break;
case "Blake2b - 512 bit":
hash = new Blake2bDigest(512);
break;
case "SHA-1":
hash = new Sha1Digest();
break;
case "SHA-2 256 bit":
hash = new Sha256Digest();
break;
case "SHA-2 512 bit":
hash = new Sha512Digest();
break;
case "SHA-3 256 bit":
hash = new Sha3Digest(256);
break;
case "SHA-3 512 bit":
hash = new Sha3Digest(512);
break;
default:
hash = new Sha1Digest();
break;
}
byte[] result = new byte[hash.GetDigestSize()];
using (Stream source = File.OpenRead(this.LocationTextBox.Text))
{
int BytesRead;
while ((BytesRead = source.Read(this._Data, 0, this._Data.Length)) > 0)
{
hash.BlockUpdate(this._Data, 0, BytesRead);
}
}
hash.DoFinal(result, 0);
Array.Clear(this._Data, 0, this._Data.Length);
return(Entities.HashFunctionList.ByteArrayToHexString(result));
}
public virtual void DoTest12()
{
BigInteger mod = new BigInteger("B3ABE6D91A4020920F8B3847764ECB34C4EB64151A96FDE7B614DC986C810FF2FD73575BDF8532C06004C8B4C8B64F700A50AEC68C0701ED10E8D211A4EA554D", 16);
BigInteger pubExp = new BigInteger("65537", 10);
BigInteger priExp = new BigInteger("AEE76AE4716F77C5782838F328327012C097BD67E5E892E75C1356E372CCF8EE1AA2D2CBDFB4DA19F703743F7C0BA42B2D69202BA7338C294D1F8B6A5771FF41", 16);
RsaKeyParameters pubParameters = new RsaKeyParameters(false, mod, pubExp);
RsaKeyParameters privParameters = new RsaKeyParameters(true, mod, priExp);
RsaEngine rsa = new RsaEngine();
byte[] data;
byte[] m1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
byte[] m2 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
byte[] m3 = { 1, 2, 3, 4, 5, 6, 7, 8 };
//
// ISO 9796-2 - Regular Signing
//
IDigest dig = new Sha1Digest();
Iso9796d2Signer eng = new Iso9796d2Signer(rsa, dig);
//
// check message bounds
//
eng.Init(true, privParameters);
eng.BlockUpdate(m1, 0, m1.Length);
data = eng.GenerateSignature();
eng.Init(false, pubParameters);
eng.BlockUpdate(m2, 0, m2.Length);
if (eng.VerifySignature(data))
{
Fail("failed ISO9796-2 m2 verify Test 12");
}
eng.Init(false, pubParameters);
eng.BlockUpdate(m3, 0, m3.Length);
if (eng.VerifySignature(data))
{
Fail("failed ISO9796-2 m3 verify Test 12");
}
eng.Init(false, pubParameters);
eng.BlockUpdate(m1, 0, m1.Length);
if (!eng.VerifySignature(data))
{
Fail("failed ISO9796-2 verify Test 12");
}
}
private void btnDigest_Click2(object sender, EventArgs e)
{
Sha1Digest dig = new Sha1Digest();
byte[] msgBytes = File.ReadAllBytes(lblDocument.Text);
dig.BlockUpdate(msgBytes, 0, msgBytes.Length);
byte[] result = new byte[dig.GetDigestSize()];
dig.DoFinal(result, 0);
textBox1.Text = Convert.ToBase64String(result);
}
public static string ComputeHash(string input)
{
var data = Encoding.UTF8.GetBytes(input);
Sha1Digest hash = new Sha1Digest();
hash.BlockUpdate(data, 0, data.Length);
byte[] result = new byte[hash.GetDigestSize()];
hash.DoFinal(result, 0);
return(Convert.ToBase64String(result));
}
/// <summary>
/// Compute the Hash of <paramref name="data"/> using the SHA-1 algorithm.
/// </summary>
/// <remarks>The approved algorithm for hashing is SHA-1 as specified in ISO/IEC 10118-3 [5].</remarks>
/// <param name="data">Data to hash.</param>
/// <returns>Hash value.</returns>
public static byte[] ComputeHashSha1(this byte[] data)
{
IDigest sha1 = new Sha1Digest();
var h = new byte[sha1.GetDigestSize()];
sha1.BlockUpdate(data, 0, data.Length);
sha1.DoFinal(h, 0);
return(h);
}
static Asn1OctetString CreateDigestFromBytes(byte[] bytes)
{
var digest = new Sha1Digest();
digest.BlockUpdate(bytes, 0, bytes.Length);
var digestBytes = new byte[digest.GetDigestSize()];
digest.DoFinal(digestBytes, 0);
return(new DerOctetString(digestBytes));
}
public AuthorityKeyIdentifier(SubjectPublicKeyInfo spki)
{
IDigest digest = new Sha1Digest();
byte[] array = new byte[digest.GetDigestSize()];
byte[] bytes = spki.PublicKeyData.GetBytes();
digest.BlockUpdate(bytes, 0, bytes.Length);
digest.DoFinal(array, 0);
keyidentifier = new DerOctetString(array);
}
private static byte[] GetDigest(SubjectPublicKeyInfo spki)
{
IDigest digest = new Sha1Digest();
byte[] array = new byte[digest.GetDigestSize()];
byte[] bytes = spki.PublicKeyData.GetBytes();
digest.BlockUpdate(bytes, 0, bytes.Length);
digest.DoFinal(array, 0);
return(array);
}
/// <summary>
/// sha1算签名， 代付回调验签
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static string ComputeSha1(string text)
{
Sha1Digest sha1Digest = new Sha1Digest();
var retValue = new byte[sha1Digest.GetDigestSize()];
var bs = Encoding.UTF8.GetBytes(text);
sha1Digest.BlockUpdate(bs, 0, bs.Length);
sha1Digest.DoFinal(retValue, 0);
return(BitConverter.ToString(retValue).Replace("-", ""));
}
public static string Sha1(string input)
{
var data = System.Text.Encoding.UTF8.GetBytes(input);
Sha1Digest hash = new Sha1Digest();
hash.BlockUpdate(data, 0, data.Length);
byte[] result = new byte[hash.GetDigestSize()];
hash.DoFinal(result, 0);
return(Hex.ToHexString(result));
}
public override void HandlePacket(WorldClient client, ServerPacket packet)
{
var reader = packet.Reader;
int returnCode = reader.ReadInt32();
if (returnCode != 0)
{
Log.Error($"WS2GC_ANS_DISTRICT_ENTER response had invalid return code {returnCode}");
client.OnDistrictEnterFailed(client, returnCode);
return;
}
var data = new DistrictEnterInfo()
{
ReturnCode = returnCode,
DistrictServerIpAddress = new IPAddress(reader.ReadBytes(4)),
DistrictServerPort = reader.ReadUInt16(),
Timestamp = reader.ReadUInt64(),
};
// Calculate the hash used in the UDP handshake
var timestampBytes = BitConverter.GetBytes(data.Timestamp);
var sha1 = new Sha1Digest();
sha1.BlockUpdate(client._encryptionKey, 0, client._encryptionKey.Length);
sha1.BlockUpdate(timestampBytes, 0, timestampBytes.Length);
var handshakeHash = new byte[sha1.GetDigestSize()];
sha1.DoFinal(handshakeHash, 0);
data.HandshakeHash = handshakeHash;
// Calculate the encryption key used for UDP packets
sha1 = new Sha1Digest();
sha1.BlockUpdate(client._encryptionKey, 0, client._encryptionKey.Length);
sha1.BlockUpdate(handshakeHash, 0, handshakeHash.Length);
var encryptionHash = new byte[sha1.GetDigestSize()];
sha1.DoFinal(encryptionHash, 0);
var encryptionKey = new byte[16];
Buffer.BlockCopy(encryptionHash, 0, encryptionKey, 0, 16);
data.XXTEAKey = encryptionKey;
Log.Debug($"m_nReturnCode = {returnCode}");
Log.Debug($"m_nDistrictServerIPAddress = {data.DistrictServerIpAddress}");
Log.Debug($"m_nDistrictServerPort = {data.DistrictServerPort}");
Log.Debug($"m_nTimestamp = {data.Timestamp}");
Log.Debug($"m_bHandshakeHash = {Util.ByteToHexBitFiddle(data.HandshakeHash)}");
Log.Debug($"m_bXXTEAKey = {Util.ByteToHexBitFiddle(data.XXTEAKey)}");
client.OnDistrictEnterSuccess(client, data);
}
// currently useless, just keep api same, again
public static Span <byte> HKDF(int keylen, Span <byte> master, Span <byte> salt, Span <byte> info)
{
byte[] ret = new byte[keylen];
IDigest degist = new Sha1Digest();
HkdfParameters parameters = new HkdfParameters(master.ToArray(), salt.ToArray(), info.ToArray());
HkdfBytesGenerator hkdf = new HkdfBytesGenerator(degist);
hkdf.Init(parameters);
hkdf.GenerateBytes(ret, 0, keylen);
return(ret.AsSpan());
}
