public MessageContainer(Hash Sender, Hash Receiver, Hash.HashProvider HashProvider)
{
SenderHash = Sender;
ReceiverHash = Receiver;
Provider = HashProvider;
Payload = new byte[0];
}
/// <summary>
/// Objects for all chains this server is participating in
/// </summary>
//private Dictionary<Hash, BlockChain> ParticipatingChains = new Dictionary<Hash, BlockChain>();
//private Dictionary<Hash, User> KnownUsers = new Dictionary<Hash, User>();
public void Initialize(Hash.HashProvider Provider)
{
if (StoreCache != null)
{
StoreCache.Initialize();
}
KnownPeers = new ConsistentHash <Peer>(Provider);
}
/// <summary>
/// Verifies any Hashable item against a key and signature
/// </summary>
/// <typeparam name="T">The type</typeparam>
/// <param name="HashableItem">Item to verify</param>
/// <param name="signature">Signature Bytes</param>
/// <param name="Provider">Hash Provider</param>
/// <param name="VerifyCert">The cert to verify against</param>
/// <returns></returns>
public static bool Verify <T>(T HashableItem, byte[] signature, Hash.HashProvider Provider, X509Certificate2 VerifyCert) where T : Hashable
{
RSACryptoServiceProvider csp = (RSACryptoServiceProvider)VerifyCert.PublicKey.Key;
byte[] hash = HashableItem.GetHash(Provider).Bytes;
var providerOID = Hash.GetOIDForProvider(Provider);
return(csp.VerifyHash(hash, providerOID, signature));
}
/// <summary>
/// Signs any Hashable item
/// </summary>
/// <typeparam name="T">The type</typeparam>
/// <param name="HashableItem">Object to sign</param>
/// <param name="Provider">Hash provider</param>
/// <param name="SigningCert">The cert to sign with</param>
/// <returns>A</returns>
public static byte[] Sign <T>(T HashableItem, Hash.HashProvider Provider, X509Certificate2 SigningCert) where T : Hashable
{
RSACryptoServiceProvider csp = (RSACryptoServiceProvider)SigningCert.PrivateKey;
byte[] hash = HashableItem.GetHash(Provider).Bytes;
var providerOID = Hash.GetOIDForProvider(Provider);
return(csp.SignHash(hash, providerOID));
}
public MessageContainer(Hash Sender, Hash Receiver, Hash.HashProvider HashProvider, byte[] MessagePayload, Cert SenderCertificate)
{
SenderHash = Sender;
ReceiverHash = Receiver;
Payload = MessagePayload;
SenderCert = SenderCertificate;
Provider = HashProvider;
ComputeHash(Provider, SenderCert);
}
public static int ByteCount(Hash.HashProvider ForProvider, int PayloadBytes, bool ZeroIndexed)
{
int pl = Hash.GetProviderByteLength(ForProvider);
if (ZeroIndexed)
{
return(intLength + PayloadBytes + (pl * 3));
}
else
{
return(intLength + PayloadBytes + (pl * 3) + 1);
}
}
Hash[] ayKeys = null; //cache the ordered keys for better performance
public ConsistentHash(Hash.HashProvider _Provider)
{
Provider = _Provider;
}
public void ComputeHash(Hash.HashProvider Provider, Cert SigningCert) => ((IHashable)Cert).ComputeHash(Provider, SigningCert);
public static ServiceConfig Defaults(bool GenerateCerts, int DefaultCertLength, Hash.HashProvider Provider,
string SwarmName, Uri SwarmPublicUri, Uri ServerUri, Uri LocalServerUri, X509Certificate2 SigningCert,
Version ServiceApiCompartibilityVersion, Version ServiceApiVersion, IObjectCache ObjectCache)
{
var config = new ServiceConfig();
config.ServerPeerInfo = new Peer()
{
Version = new AppVersionInfo()
{
ApiCompartibilityVersion = ServiceApiCompartibilityVersion,
ApiVersion = ServiceApiVersion,
Name = Assembly.GetExecutingAssembly().GetName().FullName,
Version = Assembly.GetExecutingAssembly().GetName().Version
}
};
config.Swarm = new Swarm()
{
Accessibility = Swarm.JoinAccessibility.NoRestrictions,
RootCertMinLength = DefaultCertLength,
ServerCertMinLength = DefaultCertLength,
UserCertMinLength = DefaultCertLength,
BlobMinLength = 1024 * 128,
BlobMaxLength = 1024 * 1024,
BlobMinStorage = new TimeSpan(24, 0, 0),
ItemMinLength = 1024,
ItemMaxLength = 1024 * 128,
ItemMinStorage = new TimeSpan(24, 0, 0),
MessageMinLength = 1024,
MessageMaxLength = 1024 * 128,
MessageMinStorage = new TimeSpan(4, 0, 0),
PaddingEnforced = true,
SwarmName = SwarmName,
PublicAddress = SwarmPublicUri
};
config.Server = new Server()
{
ServiceAddress = LocalServerUri.OriginalString,
StoreCache = ObjectCache
};
//start the cache
config.Server.StoreCache.Initialize();
if (GenerateCerts)
{
var swarmKey = new CertBuilder {
Issuer = SigningCert,
SubjectName = "CN=" + config.Swarm.SwarmName,
KeyStrength = config.Swarm.RootCertMinLength,
NotBefore = DateTime.Now,
NotAfter = DateTime.Now.AddYears(10)
}.BuildX509();
config.Swarm.Cert = new Cert(swarmKey);
//config.Swarm.PublicKey = Utility.GetPublicKey(swarmKey);
var serverKey = new CertBuilder {
Issuer = SigningCert,
SubjectName = "CN=" + config.Swarm.SwarmName,
KeyStrength = config.Swarm.RootCertMinLength,
NotBefore = DateTime.Now,
NotAfter = DateTime.Now.AddYears(10)
}.BuildX509();
config.Server.Cert = new Cert(serverKey);
config.ServerPeerInfo.Cert = config.Server.Cert.RemovePrivateKey();
//config.ServerPeerInfo.ComputeHash(Provider, new Cert(SigningCert));
}
return(config);
}
/// <summary>
/// Get a Hash object for this class with a specified provider
/// </summary>
public Hash GetHash(Hash.HashProvider _Provider)
{
return(Hash.Compute(HashableData(), _Provider));
}
/// <summary>
/// Compute a hash for this object and optionally signs it
/// </summary>
/// <param name="Provider">The hash provider to use</param>
/// <param name="SigningCert">If provided the cert to sign the hash with</param>
public void ComputeHash(Hash.HashProvider Provider, Cert SigningCert = null)
{
ComputedHash = Hash.Compute(GetHashableData(), Provider, SigningCert);
}
