private static string ReadKey(string registro, string keyName)
        {
            Microsoft.Win32.RegistryKey rkey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(registro);
            if (rkey == null)
            {
                Console.WriteLine("no");
            }
            else
            {
                keyName = (string)rkey.GetValue(keyName);
            }
            return keyName;
        }

            Console.WriteLine(ReadKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\OEMInformation\\", "Model"));

   Microsoft.Win32.RegistryKey rkey;
            rkey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\OEMInformation");
            if (rkey == null)
            {
                Console.WriteLine("no");
            }
            else
            {
                string myTestKey = (string)rkey.GetValue("Model");
                Console.WriteLine(myTestKey);
            }

private void CargaArchivos(string ruta)
        {
           System.Windows.Controls.CheckBox chb = new System.Windows.Controls.CheckBox();
            chb.Content = "Instalar";
            chb.IsChecked = false;
            chb.Foreground = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Colors.Green);
            
            listProgramas.Items.Add(chb);

            string[] ubicacion = Directory.GetFiles(Environment.CurrentDirectory + ruta);
            double f;

            for (int i = 0; i < ubicacion.Length; i++)
            {
                FileVersionInfo info = FileVersionInfo.GetVersionInfo(ubicacion[i]);
                FileInfo file = new FileInfo(ubicacion[i]);

                if (file.Length < 1048576)
                {
                    f = file.Length / 1024;
                    listProgramas.Items.Add(file.Name + " Version: " + info.FileVersion + " Peso: " + f.ToString() + " Kb" + chb);
                    listProgramas.Items.Add(chb);
                }
                else
                {
                    f = file.Length / 1024;
                    double q = f / 1024;
                    listProgramas.Items.Add(file.Name + " Version: " + info.FileVersion + " Peso: " + Math.Round(q, 2).ToString() + " Mb" + chb);
                    listProgramas.Items.Add(chb);
                }
                
            }
        }

listProgramas.Items.Add(file.Name + " Version: " + info.FileVersion + " Peso: " + Math.Round(q, 2).ToString() + " Mb" + chb);

 listProgramas.Items.Add(file.Name + " Version: " + info.FileVersion + " Peso: " + f.ToString() + " Kb" + chb);

        private static void Metodo1()
        {
            const string baseurl = "https://foro.elhacker.net/index.php?action=login2";
            string user = "Usuario";
            string password = "Clave";
            HttpWebRequest req = (HttpWebRequest)WebRequest.Create(baseurl);
            CookieContainer cookie;
            req.Method = "POST";
            req.ContentType = "application/x-www-form-urlencoded";
            string login = string.Format("go=&Fuser={0}&Fpass={1}", user, password);
            byte[] postbuf = Encoding.ASCII.GetBytes(login);
            req.ContentLength = postbuf.Length;
            Stream rs = req.GetRequestStream();
            rs.Write(postbuf, 0, postbuf.Length);
            rs.Close();

            cookie = req.CookieContainer = new CookieContainer();

            WebResponse resp = req.GetResponse();
            resp.Close();
        }

public class CookieAwareWebClient : WebClient
    {
        public void Login(string loginPageAddress, NameValueCollection loginData)
        {
            CookieContainer container;

            var request = (HttpWebRequest)WebRequest.Create(loginPageAddress);

            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";

            var query = string.Join("&",
              loginData.Cast<string>().Select(key => $"{key}={loginData[key]}"));

            var buffer = Encoding.ASCII.GetBytes(query);
            request.ContentLength = buffer.Length;
            var requestStream = request.GetRequestStream();
            requestStream.Write(buffer, 0, buffer.Length);
            requestStream.Close();

            container = request.CookieContainer = new CookieContainer();

            var response = request.GetResponse();
            response.Close();
            CookieContainer = container;
        }

        public CookieAwareWebClient(CookieContainer container)
        {
            CookieContainer = container;
        }

        public CookieAwareWebClient()
          : this(new CookieContainer())
        { }

        public CookieContainer CookieContainer { get; private set; }

        protected override WebRequest GetWebRequest(Uri address)
        {
            var request = (HttpWebRequest)base.GetWebRequest(address);
            request.CookieContainer = CookieContainer;
            return request;
        }

        public static void Start()
        {
            var loginAddress = "https://foro.elhacker.net/index.php?action=login2";
            var loginData = new NameValueCollection
            {
              { "username", "Usuario" },
              { "password", "Clave" }
            };

            var client = new CookieAwareWebClient();
            client.Login(loginAddress, loginData);
        }
    }

  public static CookieContainer Login()
        {
            string userName = "Usuario";
            string password = "Clave";

            ASCIIEncoding encoding = new ASCIIEncoding();
            string postData = "Username=" + userName + "&Password=" + password;
            byte[] postDataBytes = encoding.GetBytes(postData);

            HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create("https://foro.elhacker.net/index.php?action=login2");

            httpWebRequest.Method = "POST";
            httpWebRequest.ContentType = "application/x-www-form-urlencoded";
            httpWebRequest.ContentLength = postDataBytes.Length;
            httpWebRequest.AllowAutoRedirect = false;

            using (var stream = httpWebRequest.GetRequestStream())
            {
                stream.Write(postDataBytes, 0, postDataBytes.Length);
                stream.Close();
            }

            var cookieContainer = new CookieContainer();

            using (var httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse())
            {
                using (var streamReader = new StreamReader(httpWebResponse.GetResponseStream()))
                {
                    foreach (Cookie cookie in httpWebResponse.Cookies)
                    {
                        cookieContainer.Add(cookie);
                    }
                }
            }

            return cookieContainer;
        }

    public class CookieAwareWebClient : WebClient
    {
        public CookieContainer CookieContainer { get; private set; }

        public CookieAwareWebClient()
          : this(new CookieContainer())
        { }

        public CookieAwareWebClient(CookieContainer container)
        {
            CookieContainer = container;
        }


        public bool Login(string loginPageAddress, NameValueCollection loginData)
        {
            var request = (HttpWebRequest)WebRequest.Create(loginPageAddress);

            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            request.UserAgent = "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/30.0.1599.69 Safari/537.36";

            var parameters = new StringBuilder();
            foreach (string key in loginData.Keys)
            {
                parameters.AppendFormat("{0}={1}&",
                    HttpUtility.UrlEncode(key),
                    HttpUtility.UrlEncode(loginData[key]));
            }
            parameters.Length -= 1;

            var buffer = Encoding.ASCII.GetBytes(parameters.ToString());
            request.ContentLength = buffer.Length;

            var requestStream = request.GetRequestStream();
            requestStream.Write(buffer, 0, buffer.Length);
            requestStream.Close();

            request.CookieContainer = new CookieContainer();

            var response = (HttpWebResponse)request.GetResponse();
            response.Close();

            CookieContainer = request.CookieContainer;
            return response.StatusCode == HttpStatusCode.OK;
        }

        Add cookies to WebRequest
        protected override WebRequest GetWebRequest(Uri address)
        {
            var request = (HttpWebRequest)base.GetWebRequest(address);
            request.UserAgent = "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/30.0.1599.69 Safari/537.36";
            request.CookieContainer = CookieContainer;
            return request;
        }
    }
    public class FacebookClient : CookieAwareWebClient
    {
        public bool Login(string email, string password)
        {
            var loginResult = this.Login("https://foro.elhacker.net/index.php?action=login2",
            new NameValueCollection
            {
          { "Usuario", email },
          { "Clave", password }
            });

            return loginResult;
        }

        public void GetHomePage()
        {
            Here's the magic.. Cookies are injected via an overriden
            var webRequest = GetWebRequest(new Uri("http://elhacker.net/"));

            string src = "";
            using (var webResponse = (HttpWebResponse)webRequest.GetResponse())
            {
                src = new StreamReader(webResponse.GetResponseStream()).ReadToEnd();
            }
        }
    }

// ***********************************************************************
// Author   : ElektroStudios
// Modified : 28-February-2018
// ***********************************************************************



// New()



// CookiesEnabled As Boolean
// Cookies As CookieContainer
// Timeout As Integer




using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Text;
using System.Threading.Tasks;
using Microsoft.VisualBasic;
using System.ComponentModel;
using System.Drawing;
using System.Net;
using System.Runtime.InteropServices;
using System.Web;

namespace TestProject.DevCase.Core.NET
{

    /// ----------------------------------------------------------------------------------------------------
    ///         ''' <summary>
    ///         ''' A extended <see cref="WebClient"/> component, with support for cookies and requests timeout.
    ///         ''' </summary>
    ///         ''' ----------------------------------------------------------------------------------------------------
    ///         ''' <remarks>
    ///         ''' Original idea taken from: http://www.codingvision.net/tips-and-tricks/c-webclient-with-cookies
    ///         ''' </remarks>
    ///         ''' ----------------------------------------------------------------------------------------------------
    [DisplayName(nameof(DevWebClient))]
    [Description("A extended WebClient component, with support for cookies and requests timeout.")]
    [DesignTimeVisible(false)]
    [DesignerCategory(nameof(DesignerCategoryAttribute.Component))]
    //[ToolboxBitmap(typeof(Component), "Component.bmp")]
    [ToolboxItemFilter("System.Windows.Forms", ToolboxItemFilterType.Allow)]
    [ComVisible(true)]
    public class DevWebClient : WebClient
    {


        /// ----------------------------------------------------------------------------------------------------
        ///             ''' <summary>
        ///             ''' Gets or sets a value indicating whether cookies are enabled.
        ///             ''' <para></para>
        ///             ''' Default value is <see langword="False"/>.
        ///             ''' </summary>
        ///             ''' ----------------------------------------------------------------------------------------------------
        ///             ''' <value>
        ///             ''' <see langword="True"/> if cookies are enabled; otherwise, <see langword="False"/>.
        ///             ''' </value>
        ///             ''' ----------------------------------------------------------------------------------------------------
        public bool CookiesEnabled { get; set; }

        /// ----------------------------------------------------------------------------------------------------
        ///             ''' <summary>
        ///             ''' Gets or sets the cookies associated with this <see cref="DevWebClient"/>.
        ///             ''' </summary>
        ///             ''' ----------------------------------------------------------------------------------------------------
        ///             ''' <value>
        ///             ''' The cookies associated with this <see cref="DevWebClient"/>.
        ///             ''' </value>
        ///             ''' ----------------------------------------------------------------------------------------------------
        public CookieContainer Cookies { get; set; }

        /// ----------------------------------------------------------------------------------------------------
        ///             ''' <summary>
        ///             ''' Gets or sets the time interval, in milliseconds, until the 
        ///             ''' requests made by this <see cref="DevWebClient"/> times out.
        ///             ''' </summary>
        ///             ''' ----------------------------------------------------------------------------------------------------
        ///             ''' <value>
        ///             ''' The time interval, in milliseconds, until the 
        ///             ''' requests made by this <see cref="DevWebClient"/> times out, 
        ///             ''' or <see cref="Global.System.Threading.Timeout.Infinite"/> to indicate that the 
        ///             ''' request does not time out.
        ///             ''' </value>
        ///             ''' ----------------------------------------------------------------------------------------------------
        public int Timeout { get; set; } = global::System.Threading.Timeout.Infinite;



        /// ----------------------------------------------------------------------------------------------------
        ///             ''' <summary>
        ///             ''' Initializes a new instance of the <see cref="DevWebClient"/> class.
        ///             ''' </summary>
        ///             ''' ----------------------------------------------------------------------------------------------------
        public DevWebClient()
        {
            this.Cookies = new CookieContainer();
        }



        /// ----------------------------------------------------------------------------------------------------
        ///             ''' <summary>
        ///             ''' Returns a <see cref="WebRequest"/> object for the specified resource.
        ///             ''' </summary>
        ///             ''' ----------------------------------------------------------------------------------------------------
        ///             ''' <param name="address">
        ///             ''' A <see cref="Uri"/> that identifies the resource to request.
        ///             ''' </param>
        ///             ''' ----------------------------------------------------------------------------------------------------
        ///             ''' <returns>
        ///             ''' A new <see cref="WebRequest"/> object for the specified resource.
        ///             ''' </returns>
        ///             ''' ----------------------------------------------------------------------------------------------------
        protected override WebRequest GetWebRequest(Uri address)
        {
            WebRequest request = base.GetWebRequest(address);
            request.Timeout = this.Timeout;

            if ((this.CookiesEnabled) && (request is HttpWebRequest))
                (HttpWebRequest)request.CookieContainer = this.Cookies;

            return request;
        }
        public static void start()
        {
            Uri uri = new Uri("https://foro.elhacker.net/index.php?action=login2", UriKind.Absolute);
            NetworkCredential cred = new NetworkCredential("NOMBRE", "CONTRASEÑA");
            string query = HttpUtility.ParseQueryString($"cookielength=90&user={cred.UserName}&password={cred.Password}").ToString();

            using (DevWebClient client = new DevWebClient() { CookiesEnabled = true })
            {
                client.Headers.Add(HttpRequestHeader.ContentType, "application/x-www-form-urlencoded");

                string response = client.UploadString(uri, "POST", query);
                Console.WriteLine(response);
            }
        }
    }
}