C# - WebRequest

Ejemplo # 1
public string test0(string cCarpetaDestino, string fileCer, string fileKey, string textPwd)
        {
            var values = new Dictionary<string, string>
            {
                //{ "cCarpetaDestino", cCarpetaDestino },
                { "cer", fileCer },
                { "key", fileKey},
                { "pass", textPwd}
            };
            var content = new  FormUrlEncodedContent(values);
            using (var httpClient = new  HttpClient())
            {
                try
                {
                    var response = httpClient.PostAsync(apiAddresswsFIRValidaClave, content).Result;
                    var responseString = response.Content.ReadAsStringAsync();
                    if (!oSrvSetting.ControlMEnsajeError(responseString.Result.ToString(), errors_DefUnion))
                    {
                        result = responseString.Result;
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                }
            }
            return result;
        }

Ejemplo # 2
        public string test1(string cCarpetaDestino, string fileCer, string fileKey, string textPwd)
        {
            string result = string.Empty;
            var values0 = new Dictionary<string, string>
            {
                //{ "cCarpetaDestino", cCarpetaDestino },
                { "cer", fileCer },
                { "key", fileKey},
                { "pass", textPwd}
            };
            var values = new Dictionary<string, string>();
            //values.Add("cCarpetaDestino", cCarpetaDestino);
            values.Add("cer", fileCer);
            values.Add("key", fileKey);
            values.Add("pass", textPwd);
            using ( HttpClient client = new  HttpClient())
            {
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                HttpResponseMessage response = client.PostAsync(apiAddresswsFIRValidaClave, new FormUrlEncodedContent(values0)).Result;
                var tokne = response.Content.ReadAsStringAsync().Result;
                result = tokne;
            }
            return result;
        }

Ejemplo # 3

        public string test2(string cCarpetaDestino, string fileCer, string fileKey, string textPwd)
        {
            string result = string.Empty;
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(apiAddresswsFIRValidaClave);

            // Header
            request.ContentType = "text/javascript; charset=ISO-8859-1";
            request.Method = "POST";
            //request.AllowAutoRedirect = false;
            //request.KeepAlive = false;
            //request.Timeout = 30000;
            //request.ReadWriteTimeout = 30000;
            request.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.142 Safari/537.36";
            request.Accept = "application/json, text/javascript, */*";// "application/json";
            request.ProtocolVersion = HttpVersion.Version11;
            //request.Headers.Add("Accept-Language", "de_DE");
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls;
            ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };

            string postData = "cer=" + fileCer + "&key=" + fileKey + "&pass=" + textPwd;// + "&cCarpetaDestino="+cCarpetaDestino;

            byte[] bytes = Encoding.UTF8.GetBytes(postData);
            request.ContentLength = bytes.Length;
            using (var writer = request.GetRequestStream())
            {
                writer.Write(bytes, 0, bytes.Length);
                writer.Flush();
                writer.Close();
            }

            var httpResponse = (HttpWebResponse)request.GetResponse();
            using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
            {
                var jsonReturn = streamReader.ReadToEnd();

                result = jsonReturn;
             
            }

            return result;
        }
Ejemplo # 4

        public string test3(string cCarpetaDestino, string fileCer, string fileKey, string textPwd)
        {
            string result = string.Empty;
            using (var client = new HttpClient())
            {
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

                var builder = new UriBuilder(apiAddresswsFIRValidaClave);
                var query = HttpUtility.ParseQueryString(builder.Query);
                //query["cCarpetaDestino"] = cCarpetaDestino ;
                query["cer"] = fileCer ;
                query["key"] = fileKey ;
                query["pass"] = textPwd ;
                builder.Query = query.ToString();
                string url = builder.ToString();
                var resultTask = Task.FromResult(client.GetAsync(url).Result).Result.Content;
                var resultJson = resultTask.ReadAsStringAsync().Result;

                result = resultJson.ToString();

            }

            return result;
        }

Ejemplo # 5

        public async Task<string> test4Async(string cCarpetaDestino, string fileCer, string fileKey, string textPwd)
        {
            string result = string.Empty;
            var values = new Dictionary<string, string>
            {
                // { "cCarpetaDestino", cCarpetaDestino },
                { "cer", fileCer },
                { "key", fileKey},
                { "pass", textPwd}
            };
            using (var client = new HttpClient())
            {
                var content = new StringContent(JsonConvert.SerializeObject(values), Encoding.UTF8, "application/json");
                var resultAsync = await client.PostAsync(apiAddresswsFIRValidaClave, content);
                return await resultAsync.Content.ReadAsStringAsync();
            }
        }

Ejemplo # 6

        public string test5(string cCarpetaDestino, string fileCer, string fileKey, string textPwd)
        {
            string result = string.Empty;
            string WEBSERVICE_URL = apiAddresswsFIRValidaClave;
            //string jsonData = "{ \"cCarpetaDestino\" : \"" + cCarpetaDestino + "\", \"fileCer\":\""+ fileCer + "\", \"fileKey\":\"" + fileKey + "\", \"textPwd\":\"" + textPwd + "\"   }";
            string jsonData = "{ \"cer\":\"" + fileCer + "\", \"key\":\"" + fileKey + "\", \"pass\":\"" + textPwd + "\"   }";

            var values = new Dictionary<string, string>
            {
                //{ "cCarpetaDestino", cCarpetaDestino },
                { "cer", fileCer },
                { "key", fileKey},
                { "pass", textPwd}
            };
            string postData = "cer=" + fileCer + "&key=" + fileKey + "&pass=" + textPwd;// + "&cCarpetaDestino="+ cCarpetaDestino;
            byte[] byteArray = Encoding.UTF8.GetBytes(postData);
            try
            {
                HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(WEBSERVICE_URL);
                if (webRequest != null)
                {
                    webRequest.Method = "POST";
                    webRequest.Timeout = 60000;
                    webRequest.ContentType = "application/json"; //"application/x-www-form-urlencoded"; //"application/json";
                    webRequest.Accept = "application/json,text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8";
                    /*
                    using (System.IO.Stream s = webRequest.GetRequestStream())
                    {
                        using (System.IO.StreamWriter sw = new System.IO.StreamWriter(s))
                            sw.Write(jsonData);
                    }

                    using (System.IO.Stream s = webRequest.GetResponse().GetResponseStream())
                    {
                        using (System.IO.StreamReader sr = new System.IO.StreamReader(s))
                        {
                            var jsonResponse = sr.ReadToEnd();

                            result = jsonResponse.ToString();
                            System.Diagnostics.Debug.WriteLine(String.Format("Response: {0}", jsonResponse));
                        }
                    }*/
                    StreamWriter sw = new StreamWriter(webRequest.GetRequestStream());
                    sw.Write(postData, 0, byteArray.Length);
                    sw.Close();

                    //recuperamos la peticion y la mostramos
                    HttpWebResponse respuestaGalleta = (HttpWebResponse)webRequest.GetResponse();
                    StreamReader lectorGalleta = new StreamReader(respuestaGalleta.GetResponseStream());

                    result = lectorGalleta.ReadToEnd().ToString();



                }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex.ToString());
            }
            return result;
        }

Ejemplo # 7

        public string test6Async(string cCarpetaDestino, string fileCer, string fileKey, string textPwd)
        {
            string result = string.Empty;
            // Create a request using a URL that can receive a post. 
            WebRequest request = WebRequest.Create(apiAddresswsFIRValidaClave);
            // Set the Method property of the request to POST. 
            request.Method = "POST";
            // Create POST data and convert it to a byte array. 
            string postData = "cer=" + fileCer + "&key=" + fileKey + "&pass=" + textPwd;// + "&cCarpetaDestino=" + cCarpetaDestino;
            byte[] byteArray = Encoding.UTF8.GetBytes(postData);
            // Set the ContentType property of the WebRequest. 
            request.ContentType = "application/x-www-form-urlencoded";
            // Set the ContentLength property of the WebRequest. 
            request.ContentLength = byteArray.Length;
           // Get the request stream. 
           Stream dataStream = request.GetRequestStream();
            // Write the data to the request stream. 
            dataStream.Write(byteArray, 0, byteArray.Length);
            // Close the Stream object. 
            dataStream.Close();
            // Get the response. 
            WebResponse response = request.GetResponse();
            // Display the status. 
            Console.WriteLine(((HttpWebResponse)response).StatusDescription);
            // Get the stream containing content returned by the server. 
            // The using block ensures the stream is automatically closed.
            using (dataStream = response.GetResponseStream())
            {
                // Open the stream using a StreamReader for easy access. 
                StreamReader reader = new StreamReader(dataStream);
                // Read the content. 
                string responseFromServer = reader.ReadToEnd();
                // Display the content. 
                Console.WriteLine(responseFromServer);
                result = responseFromServer;
            }
            // Close the response. 
            response.Close();
            return  result ;
        }

Gráficos SVG

Graficos SVG ó imágenes vectoriales

1- La principal ventaja de las imágenes vectoriales es que siempre mantienen la calidad y nitidez a cualquier resolución.
Las imágenes tradicionales que usan los formatos JPG, PNG, BMP, GIF y otros similares, son imágenes en mapa de bits, matriciales o rasterizadas. 
Están formadas por una serie de pixeles o puntos coloreados y al redimensionarlas o aumentar el zoom se pixelizan y pierden calidad.
Las imágenes vectoriales contienen las instrucciones para el navegador o programa de visualización de cómo crear la imagen.
Es por eso que al aumentar el zoom siguen mostrándose nítidamente a cualquier resolución.
Se puede comprobar lo anterior con la siguiente imagen.
Es un logotipo de muestra creado en formato SVG usando InkScape. Mide 800 x 500 pixeles y solo 3 KB.
Da un clic encima de ella para abrirla en una nueva pestaña y entonces aumenta el zoom del navegador usando al mismo tiempo la teclas Control y + o - del teclado numérico.

2- Otra de las ventajas de las imágenes vectoriales es su pequeño tamaño, que permite aumentar la velocidad de carga de las páginas, sin prescindir de elementos gráficos o poder emplear mayor cantidad de ellos.
3- Las imágenes son construidas por el navegador, lo que disminuye la carga y consumo de recursos en el servidor web.
4- Se pueden crear imágenes SVG animadas.

Como crear las imágenes vectoriales SVG

Las imágenes SVG se pueden crear de dos formas:

1- Usando programas de diseño gráfico, como son Illustrator, Corel Draw, Freehand o Visio, no obstante el mejor de ellos es InkScape.
También es posible convertir otras imágenes vectoriales como las que usan el formato WMF al formato SVG.
Otra opción es convertir imágenes tradicionales de mapa de bits al formato SVG.
2- Cuando se trata de elementos sencillos, podemos crear las imágenes impregnando en la página web el código necesario para representarlas. Algunos ejemplos se muestran más abajo.
Para eso los más entusiastas pueden introducir el código directamente o copiar y pegar el código de una imagen existente creada mediante software.

Los mejores programas para editar imágenes SVG

Para crear, editar y convertir otros formatos de imágenes a SVG, podemos usar programas, aplicaciones o servicios en la red.
Existen para la computadora programas muy completos y otros sencillos, dependiendo del propósito de cada persona.
Los más populares son los siguientes:

Adobe Ilustrator

Adobe Ilustrator, es un completo y complejo editor gráfico de imágenes vectoriales, en el que se pueden crear imágenes en formato SVG.
Ha alcanzado una gran fama, debido a las composiciones creadas por artistas gráficos digitales usando esta herramienta, que es muy profesional.
Lamentablemente es un programa de pago.
Puede resultar un programa muy complejo para los que buscan crear gráficos sencillos.

InkScape

InkScape es una herramienta de código abierto y gratis.
Se puede emplear para dibujar y crear imágenes vectoriales en la computadora.
Con esta aplicación podemos crear conjuntos impresionantes de forma fácil, más fácil aun si poseemos una Laptop con pantalla táctil.

Usando Inkscape para crear una imagen vectorial SVG.

Incluye diversas herramientas que facilitan la creación de imágenes vectoriales.
Muy útil es un tutorial básico (en español) incluido en el programa, al que se puede acceder desde el menú Ayuda, que nos introduce en el mundo vectorial.
Inkscape se puede descargar gratis en español desde http://www.inkscape.org/, también existen versiones portables que funcionan desde el USB.

SVG-Edit

SVG-Edit es un editor de imágenes SVG que se puede probar online y de quedar satisfecho descargar los archivos de la aplicación, para usarlo en la computadora.
Es una aplicación web de código abierto que funciona usando el navegador ya sea desde internet o en el equipo de forma local.
Está disponible para descargar en Github.
Después de descargar el paquete de la aplicación descomprímelo y abre con el navegador el archivo "svg-editor.html" que se encuentra dentro de la carpeta "editor".

Usando SVG-Edit offline, un completo editor de imágenes SVG en el navegador Firefox, para crear la imagen de portada de este articulo.

El uso del programa es bastante sencillo.
De forma similar a Inkscape incluye herramientas para dibujar, crear formas básicas, rellenar, insertar texto y otras acciones.
Los objetos se van adicionando en capas diferentes.
Incluye una librería con varias formas, para temas y objetivos diferentes .
La imagen resultante se guarda en formato SVG o se puede exportar en otros formatos gráficos.
La aplicación está disponible en español.
Con SVG-Edit creamos la imagen de portada de este articulo y también el logo de nuestro sitio web.

Otros editores de imágenes vectoriales

Otros programas famosos para la creación y edición de imágenes vectoriales son: Sketch (solo disponible para el sistema operativo MacOS), Freehand, CorelDraw y Xara X.

Minimizar y comprimir y optimizar las imágenes SVG

Las imágenes SVG al consistir en archivos de texto plano con código, se pueden minimizar y comprimir, de la misma forma que los archivos CSS o JavaScript.
Los editores de imágenes SVG siempre agregan código adicional y etiquetas, que son usadas para identificar elementos y editar estas imágenes.
Si vamos a usar las imágenes "inline", es decir impregnando su código en el HTML de las páginas y no referenciándolas del modo tradicional, necesitamos eliminar el código innecesario, porque además de ocupar espacio de forma innecesaria, puede hacer que las paginas no validen correctamente.
Para eso solo es necesario eliminar las etiquetas innecesarias y los saltos de líneas.
Esto anterior es lo que se conoce como optimizar las imágenes SVG.
Podemos hacerlo manualmente usando un editor o con uno de los servicios disponibles en internet.
Algunas de las etiquetas que se pueden eliminar son las siguientes:

id, inkscape:xxxxx, sodipodi:xxxxx, defs, metadata, rdf:xxxx, cc:Work, dc:xxxxx.

En el siguiente enlace se puede descargar un archivo que contiene dos imágenes SVG de ejemplo.
La primera de ellas fue creada y guardada con el programa InkScape, la segunda la misma imagen después de optimizarla y eliminar el código innecesario, también se le adicionó un visor (viewBox).
 
Se puede comprobar que el navegador representa las dos de forma idéntica, pero la diferencia en el código es evidente.
Se pueden descargar y guardar las imágenes anteriores y comparar la gran diferencia en el código de ambas.

Servicios de internet para comprimir y minimizar SVG

Existen varios servicios para esta tarea.
He usado los dos siguientes que recomiendo:
https://vecta.io/nano
https://www.svgminify.com/es.html

Convertir imágenes al formato SVG

Convertir imágenes en formato de mapa de bits a SVG es posible, pero generalmente no es factible.
Solo da resultado con imágenes PNG con transparencia y que sean bien sencillas.
De lo contrario la calidad es pésima y el tamaño excesivo.
Se debe tener en cuenta que la imagen correspondiente en formato SVG a una PNG, siempre debe ser menor de un 10% de su tamaño original.

Programas o servicios para convertir imágenes PNG a SVG

Al hacer una búsqueda en Google de servicios para convertir imágenes a SVG, nos encontramos con varios de ellos, que solo convierten las imágenes al formato base 64.
Base 64 no es una imagen SVG.
Podemos identificarla abriéndola con un editor o con el Blog de notas y comprobando que el código comienza con el siguiente formato:

data:;base64,RXN0YSBlcyBs

Lee más información: Como usar e insertar imágenes codificadas en base 64
Solo algunos de estos servicios realizan la conversión correctamente, con la mayoría el resultado es pésimo.
Desgraciadamente la gran mayoría exige procesos de registro que todos tratamos de evitar, para prevenir el acoso a nuestra dirección de correo electrónico.
Hemos probado los siguientes servicios de internet que son gratuitos y no requieren de registro alguno.

Potrace

Potrace es una excelente herramienta gratis para convertir imágenes de mapa de bits a vectoriales, que funciona mediante la línea de comandos offline.
Lamentablemente el resultado es solo en blanco y negro y solo admite imágenes de entrada en formatos PBM, PGM, PPM o BMP.
Incluye la utilidad mkbitmap que se puede emplear para filtrar las imágenes antes de convertirlas finalmente.
Es muy práctico para vectorizar imágenes escaneadas de dibujos o ilustraciones.
http://potrace.sourceforge.net/

Image2svg

Servicio para convertir imágenes al formato SVG, subiéndolas desde nuestro equipo.
Se puede copiar el código resultante o descargar la imagen creada.
Image2svg

PickSVG

PickSVG es otro convertidor gratis online sin registro, con buenos resultados.
https://picsvg.com/

Hilo ASPX C#

[WebMethod(EnableSession = true)]
        [ScriptMethod(ResponseFormat = ResponseFormat.Json)]
        public string Hilo() {

            List<string> d = new List<string>();
       
            d.Add(ShowTodaysInfo(100).Result);
            return JsonConvert.SerializeObject(d, Formatting.Indented);
        }
     
        /**********************************************************/
        private static async Task<string> ShowTodaysInfo(int Dato)
        {
            string ret = $"Today is {DateTime.Today:D}\n" +
                         "Today's hours of leisure: " +
                         $"{await GetLeisureHours(Dato)}";
            return ret;
        }
        static async Task<int> GetLeisureHours(int dato)
        {

            // Task.FromResult es un marcador de posición para el trabajo real que devuelve una cadena.
            var today = await Task.FromResult<string>(DateTime.Now.DayOfWeek.ToString());


            // El método entonces puede procesar el resultado de alguna manera.
            int leisureHours;
            if (today.First() == 'M')
                leisureHours = 16;
            else
                leisureHours = 5;


            leisureHours = dato;
            for (int i = 0; i < 500; i++) {
                leisureHours = leisureHours + 1;
            }
            return leisureHours;
        }

JAVASCRIPT POO

JAVASCRIPT POO
var misDatos             = new Array();
function datos(cuestionario_idpregunta,cuestionario_pregunta,cuestionario_respuestas,cuestionario_tiemporespuesta,cuestionario_id,cuestionario_tiempoconsumido,cuestionario_codigo){   
    this.cuestionario_id              = cuestionario_id;
    this.cuestionario_idpregunta      = cuestionario_idpregunta;
    this.cuestionario_pregunta        = cuestionario_pregunta;
    this.cuestionario_respuestas      = cuestionario_respuestas;
    this.cuestionario_tiemporespuesta = cuestionario_tiemporespuesta;
    this.cuestionario_tiempoconsumido = cuestionario_tiempoconsumido;
    this.cuestionario_codigo          = cuestionario_codigo;
}

misDatos[i++] = new datos("<?php echo $idpregunta; ?>","<?php echo $dato["descripcionp"]; ?><br>",objeto,"<?php echo $dato["tiempo_resolucion"] ?>","<?php echo $idcuestionario; ?>","0",'<?php echo $codigo; ?><br>');




    alert(document.getElementById("cIdUsuarioemail").value);
    alert($("#cIdUsuarioemail").attr("value"));
    alert($("#cIdUsuarioemail").val());

Google - reCAPTCHA v3

Google ha lanzado reCAPTCHA v3 para evitar los robots de spam sin la interacción del usuario. reCAPTCHA v3 nos devuelve el puntaje de spam que se puede utilizar para realizar diversas acciones en su aplicación web.

reCAPTCHA v3. olvídate de “No soy un robot”

Google ha presentado el nuevo reCAPTCHA v3, la evolución del método de identificación en la web más popular. Gracias a él millones de páginas web pueden saber que en ella está entrando un ser humano, y no un robot que pueda tener oscuras intenciones. Este CAPTCHA fue creado para poder cribar a aquellos usuarios que funcionaran de una manera mecánica, y poder distinguirlos de meras máquinas. Ahora con esta nueva versión, el método se ha vuelto más inteligente, y necesita de menos interacción por parte del usuario para que la web sepa que no es un proceso automático. Las siglas CAPTCHA quieren decir “Completely Automated Public Turing test to tell Computers and Humans Apart” ("Prueba de Turing pública completamente automatizada para diferenciar a las computadoras y los humanos") un proceso que hasta ahora necesitaba de que superáramos ciertas pruebas, como reconocer objetos, resolver fórmulas matemáticas sencillas, o bien seleccionar con un aspa el texto de “no soy un robot” algo que con la nueva versión se elimina por completo. Ya no tendremos que superar este tipo de pruebas para demostrar que somos una persona en lugar de un robot. Todo gracias a un nuevo algoritmo que es capaz de saber si estamos comportándonos como lo haría una persona, o bien como una máquina. Ahora, si el algoritmo nota algún tipo de anomalía en la actitud de quien está entrando en la web, activará de nuevo estas pruebas. De esta manera se evita ralentizar el proceso de visitar las páginas. En este algoritmo entran variables como el movimiento de nuestro ratón, o los tiempos entre las pulsaciones al ratón que hemos hecho en nuestras visitas a distintas webs, para valorar si somos una persona o una máquina. Google le ha declarado la guerra al bot, y este es uno gran ejemplo.


Registre su sitio web y obtenga clave secreta
Lo primero que debe hacer es registrar su sitio web en Google reCAPTCHA para hacerlo, haga clic aquí.

Inicie sesión en su cuenta de Google y cree la aplicación rellenando el formulario. Seleccione el reCAPTCHA v3 y en esa opción de casilla de verificación "No soy un robot".

Credenciales
Una vez enviado, Google le proporcionará la siguiente información.

Clave del sitio
Llave secreta

Integra Google reCAPTCHA en tu sitio web.
Para integrarlo en su sitio web, debe colocarlo tanto en el lado del cliente como en el lado del servidor. En la página HTML del cliente, debe integrar esta línea antes de la etiqueta.

Nota:

Google reCAPTCHA v3 es invisible. No verás una forma de captcha de ningún tipo en tu página web. Necesitas capturar la respuesta de google captcha en tu código JavaScript. Aquí hay un pequeño fragmento.

Ícono reCAPTCHA
Esto generará un formulario y si se da cuenta, en la esquina derecha, verá un ícono reCAPTCHA de Google.

Como no tenemos un estilo de casilla de verificación, debemos capturar la respuesta de Google reCAPTCHA y enviarla al back-end para su verificación.

En el código, en el formulario de envío, obtenemos el token utilizando la función execute () de reCAPTCHA y pasamos el token junto con el correo electrónico y el comentario al código PHP, ASP mediante la función jQuery Ajax.

En el lado del servidor, vamos a usar PHP o ASP por ahora. Entonces, en la solicitud de envío de formulario, verificaremos la variable POST.

Ejecuta el código y rellena el formulario. Si Google no lo reconoce como un spammer, verá un cuadro de alerta que muestra el siguiente mensaje.

Respuesta API

Realice la solicitud para verificar el token de respuesta como con reCAPTCHA v2 o Invisible reCAPTCHA. La respuesta es un objeto JSON:

{
  "success": true|false,
  "challenge_ts": timestamp,  // timestamp of the challenge load (ISO format yyyy-MM-dd'T'HH:mm:ssZZ)
  "hostname": string,         // the hostname of the site where the reCAPTCHA was solved
  "error-codes": [...]        // optional
}

ASP

namespace Clase.Object
{
    public class ObjCaptcha
    {
        private string apiAddress = "https://www.google.com/recaptcha/api/siteverify";

        private string recaptchaSecret = Properties.Settings.Default.RecaptchaPrivateKey;

        public string RecaptchaVerify(string recaptchaToken)
        {
            string url = $"{apiAddress}?secret={recaptchaSecret}&response={recaptchaToken}";
            using (var httpClient = new HttpClient())
            {
                try
                {

                    string responseString = httpClient.GetStringAsync(url).Result;
                    return responseString;

                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                }
            }
        }

}
        public class ResponseToken
        {

            public DateTime challenge_ts { get; set; }
            public float score { get; set; }
            public List<string> ErrorCodes { get; set; }
            public bool Success { get; set; }
            public string hostname { get; set; }
        }

 
}

Llamado ASP

<script src="https://www.google.com/recaptcha/api.js?render=token_key"></script>
    <script>
        grecaptcha.ready(function () {
            grecaptcha.execute(token_key, { action: 'homepage' }).then(function (token) {
                var recaptchaResponse = document.getElementById('recaptchaResponse');
                recaptchaResponse.value = token;
                $.ajax({
                    type: 'POST',
                    url: 'Captcha',
                    data: "{'token':'" + token + "'}",
                    contentType: 'application/json; utf-8',
                    dataType: 'json',
                    success: function (data) {
                        if (data.d != null || data.d.Estatus != false) {
                            if (data.d.Estatus != false) {
                            }
                        } else {
                        }
                    },
                    error: function (jqXHR, textStatus, errorThrown) {
                    }
                });
            });
        });
    </script>

ObjCaptcha objCaptchas         = new ObjCaptcha();
            var responseString             = objCaptchas.RecaptchaVerify(token);
            ResponseToken response         = new ResponseToken();
            response = Newtonsoft.Json.JsonConvert.DeserializeObject<ResponseToken>(responseString.Result);

PHP

$email;$comment;$captcha;
  $email = filter_input(INPUT_POST, 'email', FILTER_VALIDATE_EMAIL);
  $comment = filter_input(INPUT_POST, 'comment', FILTER_SANITIZE_STRING);
  $captcha = filter_input(INPUT_POST, 'token', FILTER_SANITIZE_STRING);
  if(!$captcha){
    echo '<h2>Please check the the captcha form.</h2>';
    exit;
  }
  $secretKey = "-----put your secret here------";
  $ip = $_SERVER['REMOTE_ADDR'];

  // post request to server
  $url = 'https://www.google.com/recaptcha/api/siteverify';
  $data = array('secret' => $secretKey, 'response' => $captcha);

  $options = array(
    'http' => array(
      'header'  => "Content-type: application/x-www-form-urlencoded\r\n",
      'method'  => 'POST',
      'content' => http_build_query($data)
    )
  );
  $context  = stream_context_create($options);
  $response = file_get_contents($url, false, $context);
  $responseKeys = json_decode($response,true);
  header('Content-type: application/json');
  if($responseKeys["success"]) {
    echo json_encode(array('success' => 'true'));
  } else {
    echo json_encode(array('success' => 'false'));
  }

Llamado PHP

<html>
  <head>
    <title>Google recapcha v3 demo - Codeforgeek</title>
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
      <script src="https://www.google.com/recaptcha/api.js?render=put your site key here"></script>
  </head>
  <body>
    <h1>Google reCAPTHA Demo</h1>
    <form id="comment_form" action="form.php" method="post" >
      <input type="email" name="email" placeholder="Type your email" size="40"><br><br>
      <textarea name="comment" rows="8" cols="39"></textarea><br><br>
      <input type="submit" name="submit" value="Post comment"><br><br>
    </form>
      <script>
       // when form is submit
    $('#comment_form').submit(function() {
        // we stoped it
        event.preventDefault();
        var email = $('#email').val();
        var comment = $("#comment").val();
        // needs for recaptacha ready
        grecaptcha.ready(function() {
            // do request for recaptcha token
            // response is promise with passed token
            grecaptcha.execute('put your site key here', {action: 'create_comment'}).then(function(token) {
                // add token to form
                $('#comment_form').prepend('<input type="hidden" name="g-recaptcha-response" value="' + token + '">');
                    $.post("form.php",{email: email, comment: comment, token: token}, function(result) {
                            console.log(result);
                            if(result.success) {
                                    alert('Thanks for posting comment.')
                            } else {
                                    alert('You are spammer ! Get the @$%K out.')
                            }
                    });
            });;
        });
  });
  </script>
  </body>
</html>



Interpretando la partitura

reCAPTCHA v3 devuelve una puntuación (1.0 es muy probable que sea una buena interacción, 0.0 es muy probable que sea un bot). En función de la puntuación, puede realizar acciones variables en el contexto de su sitio. Cada sitio es diferente, pero a continuación hay algunos ejemplos de cómo los sitios usan la puntuación. Como en los ejemplos a continuación, actúe entre bastidores en lugar de bloquear el tráfico para proteger mejor su sitio.

Use case	Recomendación
homepage	Vea una vista coherente de su tráfico en la consola de administración mientras filtra los raspadores.
login	Con puntajes bajos, se requiere autenticación de 2 factores o verificación por correo electrónico para evitar ataques de relleno de credenciales.
social	Limite las solicitudes de amigos sin respuesta de usuarios abusivos y envíe comentarios riesgosos a la moderación.
e-commerce	Ponga sus ventas reales por delante de los robots e identifique las transacciones de riesgo.

C# - Global.asax

El global.asax es el archivo de aplicación para todo proyecto ASP.NET, se encuentra en la raíz del proyecto. En él se declaran todos los eventos a nivel de aplicación como el inicio y fin de la misma, las peticiones web, etc... Es la evolución del antiguo global.asa existente en entornos de ASP clásico.

Se compila cada vez que inicia la aplicación. Cualquier modificación del archivo es detectada y origina el reinicio de la misma.

Eventos del global.asax

Entre todos los eventos global.asax, cabe destacar como principales los siguientes:

• Application_Init: Inicio de la aplicación
• Application_Disposed: Se dispara justo antes de que una aplicación sea destruida. Este método es ideal para limpiar anteriormente recursos que fueron utilizados.
• Application_Start: Se dispara cuando se ha creado la primera instancia de la clase HttpApplication. Esto permite crear objetos que son accesibles a las todas las instancias de HttpApplication.
• Application_End: Último evento lanzado antes de finalizar por completo la aplicación.
• Application_Error: Se ejecuta cuando salta un error no controlado dentro de la aplicación.
• Application_BeginRequest: Evento lanzado por cada petición de un cliente, ya sea el acceso a una url, una imagen, etc...
• Application_EndRequest: Último evento antes de dar finalizada una petición.
• Session_Start: Nueva sesión iniciada por un usuario. Muy usado junto al session_end para establecer contadores de usuarios activos.
• Session_End: Fin de sesión para un usuario.

Usos del global.asax

Puede ser usado para múltiples tareas de gestión de las aplicaciones. Unos ejemplos pueden ser:

• Declaración de filtros globales en el global.asax.
• Interactuar con todas las peticiones. Puede usarse para gestionar las peticiones, modificar variables de app, crear un log de las mismas, etc...
• Declarar modulos como el propio enrutado de asp.net.
• Gestionar los errores de la aplicación. Recogiendo los mismos dentro del evento onApplicationError, se puede establecer un control de estos, guardando un log y gestionando las redirecciones según el tratamiento deseado

using System;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Web;
usingSystem.Web.Security;
usingSystem.Web.SessionState;

namespace WebApplication1
{
    public class Global : System.Web.HttpApplication
    {

        void Application_Start(object sender, EventArgs e)
        {
            // Código que se ejecuta al iniciarse la aplicación

        }

        void Application_End(object sender, EventArgs e)
        {
             //  Código que se ejecuta cuando se cierra la aplicación

        }

        void Application_Error(object sender, EventArgs e)
        {
             // Código que se ejecuta al producirse un error no controlado

        }

        void Session_Start(object sender, EventArgs e)
        {
             // Código que se ejecuta cuando se inicia una nueva sesión

        }

        void Session_End(object sender, EventArgs e)
        {
             // Código que se ejecuta cuando finaliza una sesión.
            // Nota: el evento Session_End se desencadena sólo cuando el modo sessionstate
            // se establece como InProc en el archivo Web.config. Si el modo de sesión se establece como StateServer 
            // o SQLServer, el evento no se genera.

        }

    }
}

Paginas Web - Tipos MIME

 Hay dos tipos primarios de MIME son importantes para el rol de tipos por defecto:

1. text/plain es el valor por defecto para los archivos textuales. Un archivo textual debe ser legible y no puede contener datos binarios.
2. application/octet-stream es el valor por defecto para todos los demás casos. Un tipo de archivo desconocido debe usar este tipo. Los navegadores tienen un cuidado particular cuando manipulan estos archivos, tratando de proteger al usuario previéndo comportamientos peligrosos.

IANA es el registro oficial de los tipos de media MIME y mantiene una lista oficial de todos los tipos de MIME. Esta tabla, lista algunos de los tipos de MIME importantes para la web:

Extensión	Tipo de documento	Tipo de MIME
.aac	Archivo de audio AAC	audio/aac
.abw	Documento AbiWord	application/x-abiword
.arc	Documento de Archivo (múltiples archivos incrustados)	application/octet-stream
.avi	AVI: Audio Video Intercalado	video/x-msvideo
.azw	Formato  eBook Amazon Kindle	application/vnd.amazon.ebook
.bin	Cualquier tipo de datos binarios	application/octet-stream
.bz	Archivo BZip	application/x-bzip
.bz2	Archivo BZip2	application/x-bzip2
.csh	Script C-Shell	application/x-csh
.css	Hojas de estilo (CSS)	text/css
.csv	Valores separados por coma (CSV)	text/csv
.doc	Microsoft Word	application/msword
.epub	Publicación Electrónica (EPUB)	application/epub+zip
.gif	Graphics Interchange Format (GIF)	image/gif
.htm	Hipertexto (HTML)	text/html
.html
.ico	Formato Icon	image/x-icon
.ics	Formato iCalendar	text/calendar
.jar	Archivo Java (JAR)	application/java-archive
.jpeg	Imágenes JPEG	image/jpeg
.jpg
.js	JavaScript (ECMAScript)	application/javascript
.json	Formato JSON	application/json
.mid	Interfaz Digital de Instrumentos Musicales (MIDI)	audio/midi
.midi
.mpeg	Video MPEG	video/mpeg
.mpkg	Paquete de instalación de Apple	application/vnd.apple.installer+xml
.odp	Documento de presentación de OpenDocument	application/vnd.oasis.opendocument.presentation
.ods	Hoja de Cálculo OpenDocument	application/vnd.oasis.opendocument.spreadsheet
.odt	Documento de texto OpenDocument	application/vnd.oasis.opendocument.text
.oga	Audio OGG	audio/ogg
.ogv	Video OGG	video/ogg
.ogx	OGG	application/ogg
.pdf	Adobe Portable Document Format (PDF)	application/pdf
.ppt	Microsoft PowerPoint	application/vnd.ms-powerpoint
.rar	Archivo RAR	application/x-rar-compressed
.rtf	Formato de Texto Enriquecido (RTF)	application/rtf
.sh	Script Bourne shell	application/x-sh
.svg	Gráficos Vectoriales (SVG)	image/svg+xml
.swf	Small web format (SWF) o Documento Adobe Flash	application/x-shockwave-flash
.tar	Aerchivo Tape (TAR)	application/x-tar
.tif	Formato de archivo de imagen etiquetado (TIFF)	image/tiff
.tiff
.ttf	Fuente TrueType	font/ttf
.vsd	Microsft Visio	application/vnd.visio
.wav	Formato de audio de forma de onda (WAV)	audio/x-wav
.weba	Audio WEBM	audio/webm
.webm	Video WEBM	video/webm
.webp	Imágenes WEBP	image/webp
.woff	Formato de fuente abierta web (WOFF)	font/woff
.woff2	Formato de fuente abierta web (WOFF)	font/woff2
.xhtml	XHTML	application/xhtml+xml
.xls	Microsoft Excel	application/vnd.ms-excel
.xml	XML	application/xml
.xul	XUL	application/vnd.mozilla.xul+xml
.zip	Archivo ZIP	application/zip
.3gp	Contenedor de audio/video 3GPP	video/3gpp
		audio/3gpp if it doesn't contain video
.3g2	Contenedor de audio/video 3GPP2	video/3gpp2
		audio/3gpp2 if it doesn't contain video
.7z	Archivo 7-zip	application/x-7z-compressed