Beispiel #1
0
        // TODO add exceptions for operations with missing keys

        public Curve25519KeyPair()
        {
            byte[] privateKey;
            byte[] edPublicKey;
            byte[] xPrivateKey;
            byte[] xPublicKey;

            // Generates keys until the conversion algorithm works for that key (there is probably a <1/100000 chance of this, but hey)
            while (true)
            {
                privateKey = new byte[Ed25519PrivateKeyParameters.KeySize];
                Ed25519.GeneratePrivateKey(new SecureRandom(), privateKey);

                edPublicKey = new byte[Ed25519PublicKeyParameters.KeySize];
                Ed25519.GeneratePublicKey(privateKey, 0, edPublicKey, 0);

                xPrivateKey = ConvertEdPrivateKeyToMontgomery(privateKey);

                xPublicKey = new byte[X25519PublicKeyParameters.KeySize];
                X25519.GeneratePublicKey(xPrivateKey, 0, xPublicKey, 0);

                if (xPublicKey.SequenceEqual(ConvertEdPublicKeyToMontgomery(edPublicKey)))
                {
                    break;
                }
            }

            _edPrivateKey = privateKey;
            _XprivateKey  = xPrivateKey;

            _edPublicKey = edPublicKey;
            _XpublicKey  = xPublicKey;
        }
 public X25519PublicKeyParameters GeneratePublicKey()
 {
     byte[] publicKey = new byte[X25519.PointSize];
     X25519.GeneratePublicKey(data, 0, publicKey, 0);
     return(new X25519PublicKeyParameters(publicKey, 0));
 }
Beispiel #3
0
        public Curve25519KeyPair(byte[] key, bool isPrivate, bool isEd25519)
        {
            // both can only be recovered if the input is an edwards key
            if (isEd25519)
            {
                if (isPrivate)
                {
                    _edPrivateKey = key;

                    byte[] xPrivateKey = ConvertEdPrivateKeyToMontgomery(key);

                    byte[] edPublicKey = new byte[Ed25519PublicKeyParameters.KeySize];
                    Ed25519.GeneratePublicKey(key, 0, edPublicKey, 0);

                    byte[] xPublicKey = new byte[X25519PublicKeyParameters.KeySize];
                    X25519.GeneratePublicKey(xPrivateKey, 0, xPublicKey, 0);

                    if (!xPublicKey.SequenceEqual(ConvertEdPublicKeyToMontgomery(edPublicKey)))
                    {
                        throw new CryptographicException(
                                  "The supplied Ed25519 private key is invalid for use: please use another.");
                    }

                    _XprivateKey = xPrivateKey;

                    _edPublicKey = edPublicKey;
                    _XpublicKey  = xPublicKey;
                }
                else
                {
                    _edPublicKey  = key;
                    _edPrivateKey = null;

                    _XpublicKey  = ConvertEdPublicKeyToMontgomery(key);
                    _XprivateKey = null;
                }
            }
            else
            {
                if (isPrivate)
                {
                    _XprivateKey = key;

                    byte[] xPublicKey = new byte[X25519PublicKeyParameters.KeySize];
                    X25519.GeneratePublicKey(key, 0, xPublicKey, 0);

                    _XpublicKey = xPublicKey;

                    _edPublicKey  = null;
                    _edPrivateKey = null;
                }
                else
                {
                    _XpublicKey = key;

                    _XprivateKey  = null;
                    _edPublicKey  = null;
                    _edPrivateKey = null;
                }
            }
        }