SSH.NET/Renci.SshClient/Renci.SshNet/Security/CryptoPublicKeyDss.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using Renci.SshNet.Common;
using Renci.SshNet.Security.Cryptography;

namespace Renci.SshNet.Security
{
    /// <summary>
    /// Represents DSS public key
    /// </summary>
    public class CryptoPublicKeyDss : CryptoPublicKey
    {
        private byte[] _p;
        private byte[] _q;
        private byte[] _g;
        private byte[] _publicKey;

        /// <summary>
        /// Gets key name.
        /// </summary>
        public override string Name
        {
            get { return "ssh-dss"; }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CryptoPublicKeyDss"/> class.
        /// </summary>
        public CryptoPublicKeyDss()
        {

        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CryptoPublicKeyDss"/> class.
        /// </summary>
        /// <param name="p">The p value.</param>
        /// <param name="q">The q value.</param>
        /// <param name="g">The g value.</param>
        /// <param name="publicKey">The public key value.</param>
        public CryptoPublicKeyDss(byte[] p, byte[] q, byte[] g, byte[] publicKey)
        {
            this._p = p;
            this._q = q;
            this._g = g;
            this._publicKey = publicKey;
        }

        /// <summary>
        /// Loads key specific data.
        /// </summary>
        /// <param name="data">The data.</param>
        public override void Load(IEnumerable<byte> data)
        {
            MemoryStream ms = null;
            try
            {
                ms = new MemoryStream(data.ToArray());
                using (var br = new BinaryReader(ms))
                {

                    var pl = (uint)(br.ReadByte() << 24 | br.ReadByte() << 16 | br.ReadByte() << 8 | br.ReadByte());

                    _p = br.ReadBytes((int)pl);

                    var ql = (uint)(br.ReadByte() << 24 | br.ReadByte() << 16 | br.ReadByte() << 8 | br.ReadByte());

                    _q = br.ReadBytes((int)ql);

                    var gl = (uint)(br.ReadByte() << 24 | br.ReadByte() << 16 | br.ReadByte() << 8 | br.ReadByte());

                    _g = br.ReadBytes((int)gl);

                    var xl = (uint)(br.ReadByte() << 24 | br.ReadByte() << 16 | br.ReadByte() << 8 | br.ReadByte());

                    _publicKey = br.ReadBytes((int)xl);
                }
            }
            finally
            {
                if (ms != null)
                {
                    ms.Dispose();
                    ms = null;
                }
            }
        }

        /// <summary>
        /// Verifies the signature.
        /// </summary>
        /// <param name="hash">The hash.</param>
        /// <param name="signature">The signature.</param>
        /// <returns>
        /// true if signature verified; otherwise false.
        /// </returns>
        public override bool VerifySignature(IEnumerable<byte> hash, IEnumerable<byte> signature)
        {

            long i = 0;
            long j = 0;
            byte[] tmp;
            var sig = signature.ToArray();
            if (sig[0] == 0 && sig[1] == 0 && sig[2] == 0)
            {
                long i1 = (sig[i++] << 24) & 0xff000000;
                long i2 = (sig[i++] << 16) & 0x00ff0000;
                long i3 = (sig[i++] << 8) & 0x0000ff00;
                long i4 = (sig[i++]) & 0x000000ff;
                j = i1 | i2 | i3 | i4;

                i += j;

                i1 = (sig[i++] << 24) & 0xff000000;
                i2 = (sig[i++] << 16) & 0x00ff0000;
                i3 = (sig[i++] << 8) & 0x0000ff00;
                i4 = (sig[i++]) & 0x000000ff;
                j = i1 | i2 | i3 | i4;

                tmp = new byte[j];
                Array.Copy(sig, (int)i, tmp, 0, (int)j);
                sig = tmp;
            }

            var sig1 = new DsaDigitalSignature(_p, _q, _g, null, _publicKey);
            return sig1.VerifySignature(hash.ToArray(), sig);
        }

        /// <summary>
        /// Gets key data byte array.
        /// </summary>
        /// <returns>
        /// The data byte array.
        /// </returns>
        public override IEnumerable<byte> GetBytes()
        {
            return new DsaPublicKeyData
            {
                P = this._p,
                Q = this._q,
                G = this._g,
                Public = this._publicKey,
            }.GetBytes();
        }

        private class DsaPublicKeyData : SshData
        {
            public byte[] P { get; set; }

            public byte[] Q { get; set; }

            public byte[] G { get; set; }

            public byte[] Public { get; set; }

            protected override void LoadData()
            {
            }

            protected override void SaveData()
            {
                this.Write("ssh-dss");
                this.WriteBinaryString(this.P);
                this.WriteBinaryString(this.Q);
                this.WriteBinaryString(this.G);
                this.WriteBinaryString(this.Public);
            }
        }
    }
}