/// <summary> /// Returns the public key of this server from the certificate file. /// </summary> /// <returns></returns> public static NodePublicKey GetServerPublicKey() { FieldPublicKey key = new FieldPublicKey( GetServerPublicKeyString()); return(NodePublicKey.BuildWith(key)); }
/// <summary> /// Checks to see if the given public key is on the Key Ring. /// Note that if the Key Ring is empty, then this function will /// add this key to the Key Ring and return true! This is the /// intended behavior (to bond with the first remote host that /// connects with it). If you don't want that behavior, then /// provide your own key file with a "safe" public key. /// </summary> /// <param name="key"></param> /// <returns></returns> public static bool PublicKeyRingHasKey(NodePublicKey key) { if (key == null) { throw new ArgumentNullException("key"); } lock (Instance.m_keyRing_Lock) { KeyRingInit(); //make sure we've loaded the keyring if (Instance.m_keyRing.Keys.Count == 0) { //No keys, so we bond with the first one, //like a newly hatched chick Instance.m_keyRing = Instance.m_keyRing.Keys.Append(key); KeyRingSave(); return(true); } else { //check against each key individually bool found = false; foreach (NodePublicKey pubKey in Instance.m_keyRing.Keys) { if (pubKey.Key == key.Key) { found = true; break; } } return(found); } } }
/// <summary> /// Removes an existing public key from the KeyRing (if it's there) /// and then saves the new ring to the PublicKeyRing file. /// </summary> /// <param name="key">New public key to remove</param> public static void PublicKeyRingRemove(NodePublicKey key) { if (key == null) { throw new ArgumentNullException("key"); } lock (Instance.m_keyRing_Lock) { KeyRingInit(); //make sure we've loaded the keyring NodePublicKey findKey = null; foreach (NodePublicKey item in Instance.m_keyRing.Keys) { if (item.Key == key.Key) { findKey = item; break; } } if (findKey != null) { Instance.m_keyRing = Instance.m_keyRing.Keys.Remove(findKey); KeyRingSave(); } } }
/// <summary> /// Adds a new public key to the KeyRing (if it's not already on there) /// and then saves the new ring to the PublicKeyRing file. /// </summary> /// <param name="key">New public key to add</param> public static void PublicKeyRingAdd(NodePublicKey key) { if (key == null) { throw new ArgumentNullException("key"); } lock (Instance.m_keyRing_Lock) { KeyRingInit(); //make sure we've loaded the keyring //only add if it doesn't already exist if (!PublicKeyRingHasKey(key)) { Instance.m_keyRing = Instance.m_keyRing.Keys.Append(key); KeyRingSave(); } } }
static bool CertificateValidationCallback(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { if (sslPolicyErrors != SslPolicyErrors.None) { if (sslPolicyErrors == SslPolicyErrors.RemoteCertificateChainErrors) { //Make sure the only error is an untrusted root //(because we're assuming it's a self-signed certificate and // we're going to check it against an internal list of public keys) bool failed = false; foreach (X509ChainStatus status in chain.ChainStatus) { if (status.Status != X509ChainStatusFlags.UntrustedRoot) { failed = true; break; } } //Pull the public key out of the certificate NodePublicKey key = NodePublicKey.BuildWith(new FieldPublicKey(certificate.GetPublicKeyString())); if (!failed && PublicKeyRingHasKey(key)) { return(true); } else { Console.WriteLine("SSL Certificate Validation Error!"); Console.WriteLine(sslPolicyErrors.ToString()); return(false); } } else { Console.WriteLine("SSL Certificate Validation Error!"); Console.WriteLine(sslPolicyErrors.ToString()); return(false); } } else { return(true); } }
public static NodePublicKey BuildWith(FieldPublicKey Key) { //build fields Dictionary <FieldIdentifier, FieldBase> mutableFields = new Dictionary <FieldIdentifier, FieldBase>(); mutableFields.Add(new FieldIdentifier(m_KeyName), Key); //build children KeyedNodeCollection <NodeBase> mutableChildren = new KeyedNodeCollection <NodeBase>(); //build node NodePublicKey Builder = new NodePublicKey( new ReadOnlyDictionary <FieldIdentifier, FieldBase>(mutableFields), new ReadOnlyCollection <NodeBase>(mutableChildren)); return(Builder); }
/// <summary> /// Checks to see if the given public key is on the Key Ring. /// Note that if the Key Ring is empty, then this function will /// add this key to the Key Ring and return true! This is the /// intended behavior (to bond with the first remote host that /// connects with it). If you don't want that behavior, then /// provide your own key file with a "safe" public key. /// </summary> /// <param name="key"></param> /// <returns></returns> public static bool PublicKeyRingHasKey(NodePublicKey key) { if (key == null) { throw new ArgumentNullException("key"); } lock (Instance.m_keyRing_Lock) { KeyRingInit(); //make sure we've loaded the keyring if (Instance.m_keyRing.Keys.Count == 0) { //No keys, so we bond with the first one, //like a newly hatched chick Instance.m_keyRing = Instance.m_keyRing.Keys.Append(key); KeyRingSave(); return true; } else { //check against each key individually bool found = false; foreach (NodePublicKey pubKey in Instance.m_keyRing.Keys) { if (pubKey.Key == key.Key) { found = true; break; } } return found; } } }
public static NodePublicKey BuildWith(FieldPublicKey Key) { //build fields Dictionary<FieldIdentifier, FieldBase> mutableFields = new Dictionary<FieldIdentifier, FieldBase>(); mutableFields.Add(new FieldIdentifier(m_KeyName), Key); //build children KeyedNodeCollection<NodeBase> mutableChildren = new KeyedNodeCollection<NodeBase>(); //build node NodePublicKey Builder = new NodePublicKey( new ReadOnlyDictionary<FieldIdentifier, FieldBase>(mutableFields), new ReadOnlyCollection<NodeBase>(mutableChildren)); return Builder; }