Temas

Por archivos "multimedia" solo dire eso  

Que servicio usan mas y cuales creen que tienen mas ventajas que otros

Factores que pueden considerar son

• Seguridad
• Privacidad
• Anonimato
• Velocidad
• Disponibilidad

Yo en lo personal prefiero usar torrents pero cuando no encuentro el contenido en esa plataforma pues no me queda mas que buacar algun buen link de mega.

La encuesta la realizo por que pienzo lanzar un servicio usando torrents y queria saber su opinion.

Saludos

Muy buen dia.

Algo que aprende el dia de ayer fue a copiar un arreglo de caracteres con el operador igual sin ayuda de memcpy o strcpy y derivados.

Segun el libro no es algo que se recomiende muy a menudo pero que por lo general indican produce un codigo de ensamblador muy optimizado.

Dadas 2 Cadenas de Igual longitud es posible copiar el contenido de una en otra con  el operador igual.

Código (c) [Seleccionar] Expandir

char cadena1[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char cadena2[27] = {0};

Normalmente la operacion siguientearca error de compilacion.

Código (c) [Seleccionar] Expandir

cadena2 = cadena1;

Pero con ayuda de una estructura de datos de igual longitud:

Código (c) [Seleccionar] Expandir

struct X{
char A[27];
};


podemos por ejemplo.

Código (c) [Seleccionar] Expandir

*(struct X*)cadena2=*(struct X*)cadena1;

Repito en el libro no lo recomiendan pero indican que si lo que buscas es optimizar un poco mas el codigo generado sería una opcion valida.

En el Libro muestran una funcion generica que hace una copia de bloques como el ejemplo mostrado para cualquier cantidad arbitraria de bytes.

En lo que llegue a la casa pongo el código mencionado.

Saludos.

Muy buen dia.

Escribo este post buscando consejos para implementar en una de mis paginas web 

Tengo la siguiente pagina:

Justfirmware.com

El consejo que busco no es por diseño yo se que la pagina esta muy muy escueta y luego trabajare en el diseño.

La pagina es de momento solo una lista de links para descargar firmware desde las paginas de Mega.

Quiero construir una comunidad al rededor de esta pagina tengo la idea de implementar mi propio sistema de mensajes como si fuera un foro pero no estoy seguro si seria la mejor manera.

¿Que recomendarían ustedes?

Saludos!

Hola.

En los libros de C que tengo nunca se mencionan los datos bool. Siempre usan un Dato entero para ellos.

Obvio es solo de C++ pero...

Ahorita busque sobre ellos y solo salen referencias vagas pero ninguna referencia oficial.

Segun esto solo encontre

Código [Seleccionar] Expandir

El tipo bool es una incorporación reciente del lenguaje (1998)

Pero no menciona ninguna fuente. El uso de enteros como booleanos a mi me parece correcto siempre que solo los manejes como 0 y 1

Incluso creo que muchos compiladoradores hacen algo como:

Código (c) [Seleccionar] Expandir

typedef bool unsiged char;


Pero bueno las preguntas son:

¿A que estandar pertenece?
¿Donde esta la pagina de ese Estandar?

Saludos

Por si recuerdan el tema sobre el desafio del SETI para descifrar el mensaje Alien:

¿Puedes descifrar este mensaje «alienígena»?

Ya salio la lista de ganadores:

http://www2.mps.mpg.de/homes/heller/downloads/files/SETI_crackers.txt

La lista fue publicada por el Dr. Rene Heller en su cuenta de twitter

Segun las respuestas cito en Ingles:

1. What is the typical body height of our interstellar counterparts?
2.45 m

2. What is their typical lifetime?
180 yr

3. What is the scale of the devices they used to submit their message?
100 km

4. Since when have they been communicating interstellar?
10,000 yr

5. What kind of object do they live on?
This one is tricky because I don't know the answer myself, making this part of the experiment a blind-blind test. The spatial information translates into 0.26 AU (100 times the Earth-Moon distance, if anyone recognized). The corresponding picture shows four planets or moons, one of which seems to be inhabited by our alien friends. So they might live on the 4th planet (or on one of three moons orbiting a giant planet) in the habitable zone around a low-mass star.

6. How old is their stellar system?
6 Gyr

Nota que mas o menos explican como obtuvieron la distancia y tiempo para calcular sobre los numeros dados pero aun asi no lo dan en detalle.

Saludos.

Les dejo un programa para que juegen loteria mexicana

Código (c) [Seleccionar] Expandir

#include<stdio.h>
#include<time.h>
#include<stdlib.h>

int *barajear(int max);

char *cartas[] = {
"El Ggallo","El diablito","La dama","El Catrin","El paraguas","La sirena","La escalera","La botella","El barril","El arbol","El melon","El valiente","El gorrito","La muerte","La pera","La bandera","El bandolon","El violoncello","La garza","El pajarito","La mano","La bota","La luna","El cotorro","El borracho","El corazon","El negrito","La sandia","El tambor","El camaron","Las jaras","El musico","La araña","El soldado","La estrella","El cazo","El mundo","El apache","El nopal","El alacran","la rosa","La calavera","La campana","El cantarito","El venado","El sol","La corona","La chalupa","El pino","El pescado","La palma","La maceta","El arpa","La rana"};

int main() {
int *baraja = barajear(54);
int i = 0;
char c;
while(i<54) {
printf("%s\n",cartas[baraja[i]]);
c = fgetc(stdin);
i++;
}
}

int *barajear(int max) {
char *no_repetidos = NULL;
int *desorden = NULL;
int r = 0;
register int i = 0;
sranddev();
srand(time(NULL));
while(no_repetidos == NULL){
no_repetidos = calloc(max,sizeof(char));
}
while(desorden == NULL){
desorden = calloc(max,sizeof(int));
}
do {
r = rand() % max;
if(no_repetidos[r] == 0) {
desorden[i] = r;
no_repetidos[r] = 1;
i++;
}
}while(i < max);
free(no_repetidos);
return desorden;
}

Saludos!

Hace unos meses en una de mis clases de economia surgio esa pregunta.

El profesor en su momento nos lo explico con varias graficas de microeconomia y 2 horas completas de Clase que actualmente no recuerdo en su totalidad.

Quiero ver cuales son sus opiniones y Argumentos al respecto.

Saludos

[¿Por que se da esto?]

Muy buen dia.

Estaba pensando que es posible determinar el numero de barajas usadas en un mazo de juego de 21.

Las condiciones que se tienen que dar para poder determinar el numero exacto de barajas son las siguientes.

• El mazo de cartas solo se renueva cuando se terminan las cartas del mazo actual
• Se tiene conocimiento pleno de todas las cartas que se han repartido desde el principio del juego
• Las cartas ya usadas NO se reciclan, (Condicion igual a la UNO pero solo para dejarlo mas claro)

Dada las condiciones anteriores podemos saber cuantas barajas son usadas para crear el mazo de juego.

Vamos a obviar el contenido de algunas fuciones y solo tendremos:

Código (c) [Seleccionar] Expandir

int main() {
struct mazo *mazo_juego = crear_mazo(6); // Se crea un mazo con 6 barajas
struct carta *siguiente = NULL;
int contador = 0;
int acumulador = 0;
siguiente = siguiente_carta(mazo_juego); //Se comienza caon la primera carta
while(siguiente != NULL) {
acumulador += valor_conteo(siguiente); //Acumulador va acumulando el conteo de cartas +1 para cartas del 2 al 6 y -1 para cartas del 10 al K + el A
if(contador > 0 && (contador % 52) == 0 && acumulador == 0) {
printf("mazo nuevo\n");
printf("Cantidad de Barajas %i\n",(contador/52));
contador = 0;
}
contador++;
siguiente = siguiente_carta(mazo_juego);

}
}

La funcion valor conteo es la siguiente:

Código (c) [Seleccionar] Expandir

int valor_conteo(struct carta *actual) {
int r = 0;
switch(actual->figura) {
case 'A':
case 'K':
case 'Q':
case 'J':
case '0':
r = -1;
break;
case '2':
case '3':
case '4':
case '5':
case '6':
r = 1;
break;
}
//printf("valor de conteo de %c es %i\n",actual->figura,r);
return r;
}

La estructura de una carta es la siguiente:

Código (c) [Seleccionar] Expandir

struct carta {
char figura;
char tipo;
};


La condicion para saber el numero de barajas es la siguiente:

Código (c) [Seleccionar] Expandir

if(contador > 0 && (contador % 52) == 0 && acumulador == 0)

Lo que quiere decir que:

• El contatador de cartas debe de ser mayor a 0 y cada que determinemos que es un "mazo nuevo" reiniciarlo a 0
• El contador debe de ser un multiplo exacto de 52
• Y el acumulador debe de ser 0

En uno de mis videos mostre como este acumulador sube o baja desde un valor muy alto a un valor muy bajo para llegar a 0 al finalizar el mazo actual.

El el programa main que mostre siempre da de salida.

Código [Seleccionar] Expandir

mazo nuevo
Cantidad de Barajas 6


Ahora si cambio el algoritmo para usar N cantidad de barajas a un numero random obtengo

Código [Seleccionar] Expandir

mazo nuevo
Cantidad de Barajas 73
mazo nuevo
Cantidad de Barajas 41
mazo nuevo
Cantidad de Barajas 36
mazo nuevo
Cantidad de Barajas 31
mazo nuevo
Cantidad de Barajas 1
mazo nuevo
Cantidad de Barajas 56
mazo nuevo
Cantidad de Barajas 71
mazo nuevo
Cantidad de Barajas 37
mazo nuevo
Cantidad de Barajas 90
mazo nuevo
Cantidad de Barajas 38
mazo nuevo
Cantidad de Barajas 2
mazo nuevo
Cantidad de Barajas 4
mazo nuevo
Cantidad de Barajas 44
mazo nuevo
Cantidad de Barajas 4
mazo nuevo
Cantidad de Barajas 4
mazo nuevo
Cantidad de Barajas 5
mazo nuevo
Cantidad de Barajas 5
mazo nuevo
Cantidad de Barajas 20
mazo nuevo
Cantidad de Barajas 3
mazo nuevo
Cantidad de Barajas 41
mazo nuevo
Cantidad de Barajas 80
mazo nuevo


Aun asi existen falsos positivos, en la salida anterior yo se apriori (Por que lo programe yo) que el valor random de numero de bajaras en el mazo este entre 6 y 112  y si vemos hay valores que nos dan "3" o algo menor a 6 es en falso positivo.

¿Por que se da esto?

Debido al orden aleatorio de un mazo de juego es posible que todas las condiciones que se mencionaron se cumpla antes de terminarse realmente un mazo.

Nuevamente las condiciones son

• El contatador de cartas debe de ser mayor a 0 y cada que determinemos que es un "mazo nuevo" reiniciarlo a 0
• El contador debe de ser un multiplo exacto de 52
• Y el acumulador debe de ser 0

¿Hay forma de evitar falsos positivos?

Segun pienso NO ya que en un escenario real no puedes conocer a priori todas las variables...

¿Para que sirve determinar el numero de barajas usadas?

Como se menciona en el algoritmo de conteo de cartas es deseable saber el numero de barajas usadas en un mazo de juego para determinar si es buen momento de apostar.

El video de que comento es el siguiente:

[youtube=640,360]https://www.youtube.com/watch?v=A-NWAm0avps[/youtube]

Aun asi el código ahi mostrado no esta tan avanzado como el código que muestro en este post, pero sirve para el ejemplo didáctico de conteo de cartas aquí mostrado solo con ligeros cambios.

Saludos

Muy buen dia les dejo un funcion que devuelve una arreglo de numeros enteros no repetidos y pseudo-aleatorios.

Código (c) [Seleccionar] Expandir

int *aleatorios_no_repetidos(int max) {
char *no_repetidos = NULL;
int *desorden = NULL;
int r = 0;
register int i = 0;
srand(time(NULL));
while(no_repetidos == NULL){
no_repetidos = calloc(max,sizeof(char));
}
while(desorden == NULL){
desorden = calloc(max,sizeof(int));
}
do {
r = rand() % max;
if(no_repetidos[r] == 0) {
desorden[i] = r;
no_repetidos[r] = 1;
i++;
}
}while(i < max);
free(no_repetidos);
return desorden;
}

Funcion explicada paso a paso:

Código (c) [Seleccionar] Expandir

int *aleatorios_no_repetidos(int max) {
char *no_repetidos = NULL; //Variable auxiliar para determinar si un numero ya fue agregado o no
int *desorden = NULL; //Contenedor con los numeros en desorden y no repetidos
int r = 0; //variable temporal para el numero pseudo-aleatorio
register int i = 0; //contador de numeros en el arreglo desorden
srand(time(NULL)); //inicializamos nuestra funcion random, en otros sistemas se puede utlizar algun otro generador de numeros aleatorios ya que esta implementacion es muy pobre
//Los siguientes ciclos son usados para asignar espacio a no_repetidos, y  desorden respectivamennte se puede omitir el ciclo ya que rara vez calloc devuelve NULL, pero siempre es bueno validar que no exista error en el retorno de calloc
while(no_repetidos == NULL){
no_repetidos = calloc(max,sizeof(char));
}
while(desorden == NULL){
desorden = calloc(max,sizeof(int));
}

//El siguiente ciclo do-while es usado para rellenar los numeros mientras i se menor que el numero maximo
do {
r = rand() % max; //Aqui tenemos nuestro numero aleatorio de 0 a max - 1
if(no_repetidos[r] == 0) { //validamos que r no exista en el arreglo de no_repetidos
desorden[i] = r; //Asignamos r al arreglo de desorden
no_repetidos[r] = 1; //agregamos 1 al arreglo de no_repetidos para que el numero r actual no vuelva ser agregado
i++; //incrementamos i solo dentro del if para solo contabilizar los numeros que agregemos
}
}while(i < max);
free(no_repetidos); //Liberamos el arrgelo auxiliar de no repetidos ya que no lo necesitamos mas
return desorden; //regresamos la apuntador a desorden
}


Para usar esta funcion tenemos el siguiente ejemplo:

Código (c) [Seleccionar] Expandir

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<string.h>

int *aleatorios_no_repetidos(int max);


int main() {
int maximo = 10;
int *numeros = aleatorios_no_repetidos(maximo); // Solo numeros del 0 al 9  en desorden Los cuales son 10 en total
int i = 0;
printf("Numeros aleatorios no repetidos:\n");
while(i < maximo) {
printf("%i\t",numeros[i]);
i++;
}
printf("\n");
free(numeros);
return 0;
}



Salidas de ejemplo:

Código [Seleccionar] Expandir

Numeros aleatorios no repetidos:
9 6 7 5 3 2 8 0 4 1
Numeros aleatorios no repetidos:
6 8 5 9 7 3 0 1 4 2
Numeros aleatorios no repetidos:
3 7 8 6 2 5 1 9 0 4
Numeros aleatorios no repetidos:
3 7 8 6 2 5 1 9 0 4
Numeros aleatorios no repetidos:
3 7 8 6 2 5 1 9 0 4
Numeros aleatorios no repetidos:
0 6 4 2 1 9 3 5 8 7
Numeros aleatorios no repetidos:
0 6 4 2 1 9 3 5 8 7
Numeros aleatorios no repetidos:
0 6 4 2 1 9 3 5 8 7
Numeros aleatorios no repetidos:
7 5 0 6 1 9 8 2 3 4
Numeros aleatorios no repetidos:
7 5 0 6 1 9 8 2 3 4

Cada 2 lineas es una salida de 10 numeros del 0 al 9 no repetidos y en desorden...

Noten que hay veces que se repite por la pobre implementación de rand() con time(), recomiendo si pueden implementar otra forma de aleatorios estaría mucho mejor el programa.

Proximamente agregare el video explicando el código mencionado.

Saludos

[El Nodo a eliminar tiene ambos hijos]

Tengo un detalle al momento de eliminar un nodo del arbol binario.

Dada la estructura:

Código (c) [Seleccionar] Expandir

struct nodo {
struct nodo *padre;
struct nodo *izquierdo;
struct nodo *derecho;
char *valor;
};

Ya puedo agregar y buscar nodos sin problema y al momento de eliminar nodos hay varios casos ya aborde la mayoria de ellos solo tengo un detalle con el ultimo.

Casos:

• El Nodo a eliminar no tiene hijos (Listo)
• El Nodo a eliminar solo tiene un hijo derecho o izquierdo (Listo)
• El Nodo a eliminar tiene ambos hijos (Pendiente)

El detalles es el decidir como reconectar los nodos cuando el noda eliminar tiene 2 hijos... (Si es un problema de algoritmo pero lo pongo aqui por que esta en C)

Si esos 2 hijos no tienen hijos no hay problema simplemente selecciono uno y lo pongo en el lugar del nodo eliminado. Pero el peor de los casos es cuando ambos nodos tienes 2 hijos cada uno mas o menos asi:

Código [Seleccionar] Expandir

      p
      |
->     n
    /   \
   d     i
  / \   / \
 d   i d   i


La pregunta que tengo aqui seria la siguiente...

Tengo que hacer una funcion que reconecte y reorganize los nodos del arbol ¿Que recomendarian ustedes una funcion iterativa o una recursiva?

La otra solucion que tengo es manejar el nodo a eliminar como un arbol independiente desvincularlo del arbol principal y recorrer este nuevo subarbol de izquierda a derecha o viceversa y agregar cada nodo del subarbol al arbol principal, con excepcion de nodo a eliminar que seria la raiz del subarbol.

¿Que recomiendan ustedes?

La funcion que tengo es la siguiente:

Código (c) [Seleccionar] Expandir

void eliminar_nodo(struct nodo *arbol,char *valor) {
struct nodo *n;
struct nodo *padre;
struct nodo *derecho;
struct nodo *izquierdo;
if(debug_arbol)
debug_arbol = 0;
n = buscar_valor(arbol,valor);
if(n) {

if(n->derecho == NULL && n->izquierdo == NULL) {
//No tiene hijos, hay que determinar si es el hijo derecho o izquierdo de su padre y desvincularlo
padre = n->padre;
if(padre->derecho == n) {
padre->derecho = NULL;
free_nodo(n);
}
else {
padre->izquierdo = NULL;
free_nodo(n);
}
}
else {
if(n->derecho != NULL && n->izquierdo != NULL) {
// Tiene 2 Hijos
padre = n->padre;
// Detalle aqui.....

}
else {
if(n->derecho != NULL) { //Solo tiene al hijo derecho
derecho = n->derecho;
padre = n->padre;
if(padre->derecho == n) { //hay que determinar si es el hijo derecho o izquierdo de su padre y vincular dicho nodo, con el nodo derecho del n actual y liberar n despues de eso
padre->derecho = derecho;
free_nodo(n);
}
else {
padre->izquierdo = derecho;
free_nodo(n);
}
}
else { //Solo tiene al hijo izquierdo
izquierdo = n->izquierdo;
padre = n->padre;
if(padre->derecho == n) { //hay que determinar si es el hijo derecho o izquierdo de su padre y vincular dicho nodo, con el nodo izquierdo del n actual y liberar n despues de eso
padre->derecho = izquierdo;
free_nodo(n);
}
else {
padre->izquierdo = izquierdo;
free_nodo(n);
}
}
}
}
}
else {
printf("No existe un nodo con el valor \"%s\" en el arbol\n",valor);
}
}



Solucion en : http://foro.elhacker.net/programacion_cc/c_eliminando_nodo_de_arbol_binario-t453185.0.html;msg2072953#msg2072953

[Solo les pediria si me ayudaran a con links de listas de libros]

Muy buenas tarde comunidad estoy armando una lista de libros para tenerla en un archivo TXT con fines didacticos..

El detalle que estoy programando un Arbol (Ya tengo el codigo) solo que me pidieron que le agregara Titulos de libros y es lo que estoy buscando.

No he encontrado una lista lo bastante grande nesitaba mas de 10mil titulos de libros de ser posible mas de un millon pero me conformo con unos mil xD  

Por ejemplo busque en google por lista de libros y encontre esto:

https://es.wikipedia.org/wiki/Anexo:Los_100_mejores_libros_de_todos_los_tiempos,_seg%C3%BAn_el_Club_de_Libros_de_Noruega

Ya tengo esos 100   pero necesito encontrar alguna lista lo bastante amplia para pasarla a texto (Un libro por linea) Solo les pediria si me ayudaran a con links de listas de libros yo me encargo de pasarlos a texto.

Espero y me puedan ayudar

Si alguien sabe de alguna base de datos publica con muchisimos libros favor de avisarme  

Saludos!

Como.me gustaria ver esa platica...

:https://www.blackhat.com/us-16/briefings/schedule/#recover-a-rsa-private-key-from-a-tls-session-with-perfect-forward-secrecy-3046

In certain circumstances it is possible to derive the private key of server regardless of the size of the used modulus. Even RSA keys of 4096 bits can be factored at the cost of a few CPU cycles and computational resources.

¿Alguien sabe algo del tema?

Saludos

Muy buen dia.

Estoy tratando de implementar un pequeño programa que hice para hacerlo un servicio WEB... pero no estoy seguro de como aplicarlo en PHP

Tengo la siguiente estrucuta de C

Código (c) [Seleccionar] Expandir

struct temp{
unsigned char *valor;
unsigned int bytes;
};

Mi duda es como implementarlo correctamente en PHP, segun lei lo mas parecido es un clase en PHP

entonces tengo:

Código (php) [Seleccionar] Expandir


<?php
class temp {
public $valor[];
public $bytes;
}
?>


Mi duda es como decir que $valor tiene que ser de X cantidad;

Por ejemplo cuando leeo desde un archivo X cantidad de bytes en $valor puedo saber que $valor tiene X longitud pero no se como hacerlo a mano... esto es

Voy a crear una instanacia de esa clase y al elemento $valor le quier agregar un valor en el primer elemento y posteriormente tal vez le agrege mas. Simplemente lo agrego como

Código (php) [Seleccionar] Expandir

$valor[1] = 200;

He usado arrays pero para este caso no creo que sea lo mas eficiente..

Hace 2 dias que vi un boletin de seguridad de freebsd.

al aplicacion afectada es sendmsg

https://www.freebsd.org/security/advisories/FreeBSD-SA-16:19.sendmsg.asc

cita:

Código [Seleccionar] Expandir

Malicious local user may crash kernel or execute arbitrary code in the kernel,
potentially gaining superuser privileges.

Segun vi en mi cuenta de twitter hablaban de un root-exploit...

¿Alguien tendra algun PoC?

ya saben con fines de investigacion...

[contador_memoria]

La idea es depurar la asignacion de momeria.

Tengo un programa algo grande que necestito depurar. El programa usa memoria dinamica todo el tiempo y en general el programa funciona bien.

Sin embargo segun mis calculos el programa esa usando mas memoria de la que necesita. Algunos megas de mas 

Reemplace las llamadas a free, malloc y calloc por unas funciones para ir depurando cada que se reserva o libera memoria.

¿Alguno de ustedes ha hecho algo parecido?

¿Alguna sugerencia algun cambio?

Tengo el siguiente codigo:

Código (c) [Seleccionar] Expandir



char **punteros;
size_t *contador_size;
size_t offset_contador = 0;
size_t contador_memoria = 0;

void _free_( char *ptr) {
remove_contador(ptr);
free(ptr);
}

char *_calloc_(size_t nmemb, size_t size) {
char *ptr;
ptr = calloc(nmemb,size);
add_contador(ptr,nmemb*size);
return ptr;
}
void add_contador(char *ptr,size_t size) {
printf("add_contador: %u [0x%x] %u + %u bytes\n",offset_contador,ptr,contador_memoria,size);
punteros = realloc(punteros,(offset_contador+1)*sizeof(char*));
contador_size = realloc(contador_size,(offset_contador+1)*sizeof(size_t));
punteros[offset_contador] = ptr;
contador_size[offset_contador] = size;
contador_memoria+=size;
offset_contador++;
}

void remove_contador(char *ptr) {
size_t i = 0;
while(punteros[i] != ptr && i < offset_contador) {
i++;
}
printf("remove_contador: %u [0x%x]\n",i,ptr);
contador_memoria-=contador_size[i];
while(i < offset_contador-1) {
punteros[i] = punteros[i+1];
contador_size[i] = contador_size[i+1];
i++;
}
punteros[i] = NULL;
contador_size[i] = 0;
offset_contador--;
}

Al final solo tenemos que validar la variable contador_memoria para saber cuantos bytes quedan y offset_contador para saber cuantos apuntadore quedan.

Saludos

A ver tengo mi ejemplo de numeros de longitud variable o mejor conocidos como BigInt... (Implementacion propia) en C.

Estoy sumando byte a byte y el resultado lo guardo en una variable de 2 bytes por ejemplo cuando sumo 255 + 255 el primer byte del resultado tiene 255 y lo demas esta en el segundo byte el cual posterior al ciclo lo sumo al siguiente byte de la cadena en caso de no existir lo anexo al final y todo bien.

El detalle que al final si sumo una larga serie de 255 continuos  byte a byte llegara un momento en el que la variable se desborda...

Cual es la mejor solucion para esto? Guardar el resultado en una variable de 4 bytes y validar si existe acarreo en los bytes 3 y 4?

Que pasara cuando la variable de 4 bytes no sea suficiente...

Saludos

Estoy haciendo un sistema de tickets.

Todo funcionada bien pero ahora sale el error y estoy con que no he movido nada.

Código [Seleccionar] Expandir

Parser Error Message: 'sistetma.tickets' is not allowed here because it does not extend class 'System.Web.UI.Page'.


La pagina .aspx tiene la siguiente primera linea.

Código (html4strict) [Seleccionar] Expandir

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="tickets.aspx.cs" Inherits="sistetma.tickets" %>

Y el codigo en el aspx.cs tiene:

Código (csharp) [Seleccionar] Expandir

using System;

namespace sistema
{
   public partial class tickets : System.Web.UI.Page
   {
       protected void Page_Load(object sender, EventArgs e)
       {
...
       }
   }
}

No veo el problema..

[Otra de las razones por las que abro este tema]

Esa es la pregunta ¿Es malo, bueno, tiene ventajas, desventajas?

Aun que no he visto television local en mucho tiempo tal vez mas de 10 años, disfruto de ver peliculas en el Cine y tambien disfruto de ver algunas Series en Netflix.

Y la ventajas que veo en lo que hago son

• Veo lo que me gusta ver
• Lo veo cuando lo quiero ver
• Lo disfruto sin comerciales

La siguiente es una lista de por que no veo Television Local.

• Tiene comerciales, muchos comerciales
• Tu no elijes el contenido (Claro puedes buscar un canal que te guste)
• Contenido de poca o nula calidad (Hay excepciones pero muy rara vez)

Aqui en mexico hay muy pocos canales y tenemos un duopolio televisivo que dicta lo que ve la mayoria de los mexicanos, que en la mayoria de las ocasiones no pasa de novelas y o programas de baja calida, peliculas repetidas de hace 10 años etc..

En fin

Otra de las razones por las que abro este tema es que muchas veces me siento mal por no poder seguir una conversacion con mis amigos cuando el tema es algo del momento de lo cual solo te enteras en programas de chismes televisivos.

Por ejemplo hoy me dicen por el grupo de Telegram que tenemos.

-Ya vieron que se murio fulanito.

A lo que contesto ¿Quien es fulanito?. Y me contestan

No puede ser que no lo conozcas, si a salido asi y alla... (Exclusivamente television local)

Y replico, realmente no lo conozco.


Y no es la primera vez que pasa, algunas veces hablan de cosas que pasan (En television) y yo me quedo ... de que hablan, por que hablan de esas cosas. ¿Podriamos volver al tema de computacion y/o matematicas o minimo hablar de las ultimas canciones de rock del grupo que nos gusta?

Siempre me han conocido por saber de muchos temas menos de television, y aun que se entraria en el tema de Conocimiento General, realmente no creo que los chismes de television deban entrar en la categoria de Conocimiento General incluso no creo que deban de ser considerado conocimiento

¿Que opinan ustedes?

[Ahora necesito imprimirlos en formato decimal]

Muy buen dia.

Tengo entre manos el siguiente problema.

Tengo en memoria un buffer que contiene números de gran longitud, puedo sumarlos, restarlos, dividirlos etc.

Ahora necesito imprimirlos en formato decimal, actualmente solo tengo forma de visualizarlos en formado hexadecimal.

ejemplo:

Código [Seleccionar] Expandir

numero 1: 0000000000000020a7c0a09f032703
numero 2: 00000000000000000000000000000021a45141d6351f
numero 3: 00000000000000001ed31c62dfa50b
numero 4: 00000000000000000000000000000044b5f2b7695b70
numero 5: 00000000000000000040ab08571d224107
numero 6: 000000000000000000000000000000003ac807630f6218
numero 7: 00000000000000000000000072b11568f28c2a
numero 8: 000000000000000000000000000000000000607fe65ec43bdf

Numeros en Little Endian.


Lo anterior lo hago solo imprimiendo byte a byte en hexadecimal.

La pregunta aqui es.. ¿debo de busca el algoritmo ya hecho para convertir de entero a "Cadena Decimal" usado por itoa?

O recomiendan algun otro algoritmo que sea mas adecuado para números largos, repito el numero ya lo tengo en memoria y es de N cantidad de bits

El algoritmo itoa es el siguiente:

http://opensource.apple.com//source/groff/groff-10/groff/libgroff/itoa.c

y al aprecer no funciona para numeros como el que tengo.

Código (c) [Seleccionar] Expandir

#define INT_DIGITS 19 /* enough for 64 bit integer */

char *itoa(i)
     int i;
{
  /* Room for INT_DIGITS digits, - and '\0' */
  static char buf[INT_DIGITS + 2];
  char *p = buf + INT_DIGITS + 1; /* points to terminating '\0' */
  if (i >= 0) {
    do {
      *--p = '0' + (i % 10);
      i /= 10;
    } while (i != 0);
    return p;
  }
  else { /* i < 0 */
    do {
      *--p = '0' - (i % 10);
      i /= 10;
    } while (i != 0);
    *--p = '-';
  }
  return p;
}


Saludos

Dejare una lista de números útiles y sus respectivos archivos:

Tabla de Numeros enteros y sus respectivos cuadrados.

• cuadrados

Lista de Números primos:

• Números primos de un byte del 2 al 251 en total 54 : 1
• Números primos de dos bytes del 257 al  65521 en total  6488 : 2
• Numeros primos de tres bytes del 65537 al  16777213 en total  1071329: 3

Seguiré subiendo los archivos mientras los compruebo que no tengan errores.

Los números anteriores están en formato Litte Endian y solo necesitan la cantidad de bytes que indica el archivo.

También agregare el código necesario para búsqueda / leerlos a memoria y lo que se necesite.


Saludos

Pues eso cual es el contenido de este archivo.

- c

Muy buen dia.

Busco un metodo 100% seguro para deterinar si un numero dado es primo o no.

Es el metodo que estoy usanfo como lo indica wikipedia es dividir el numero dado entre todos los numeros primos que ya tengo guardados que sean menores o iguales a la raiz del numero dado y si en algun momento el resto de la divicion es 0 entonces el numero no es primo.

Para hacer mas eficiente el trabajo tengo guardadas los cuadrados n^2 en una tabla y cuando pregunto por un numero N solo hago una busqueda binaria y retorno el numero n mas cercano.

Cabe mencionar que ahorita apenas llevo numeros de hasta 7 bytes.

La pregunta aqui es.

¿Hay uno que sea mas rapido y con la misma certeza?

[primos[offset]->valor]

Problema al escribir archivo...

Realmente estoy rompiéndome la cabeza desde hace unos 2 dias...  

Al momento de guardar datos en un archivo escribo los datos de 2 bytes en 2 bytes.

Todo bien pero llega un momento en que el programa no guarda la información que debe de guardar, sin embargo si mando a imprimir lo que esta guardando esta información si es correcta, pero no la que se guarda en el archivo.

Código (c) [Seleccionar] Expandir

file = fopen(nombre,"a+");
if(file) {
debug("-primos[%i]",primos[offset]->valor,primos[offset]->bytes,offset);
fwrite(primos[offset]->valor,primos[offset]->bytes,1,file);
fclose(file);
}


Mando a llamar a una función debug para ver que es lo que se esta guardando, esta función me imprime el contenido de la memoria sin afectarlo...

Código (c) [Seleccionar] Expandir


void debug(char *s,unsigned char *ptr,unsigned int l,...) {
va_list args;
int i = 0;
int len = strlen(s)*20;
char *buffer;
buffer = calloc(len,sizeof(char));
va_start(args, l);
vsprintf(buffer,s, args);
printf("%s: 0x%x ",buffer,ptr);
while(ptr && i < l) {
printf("%.2x",ptr[i++]);
}
printf("\n");
va_end(args);
memset(buffer,0,len);
free(buffer);
}

Aquí lo importante es notar que llamo a fwrite para escribir en el archivo abierto con la opcion "a+"

Código (c) [Seleccionar] Expandir

debug("-primos[%i]",primos[offset]->valor,primos[offset]->bytes,offset);
fwrite(primos[offset]->valor,primos[offset]->bytes,1,file);

La posición de memoria que se guarda es: primos[offset]->valor y la cantidad de bytes que se guardan con fwrite y se imprimen con debug es primos[offset]->bytes que para el ejemplo dado vale 2

La salida del programa va mas o menos asi...

Código [Seleccionar] Expandir

-primos[54]: 0x567fd0 0101
-primos[55]: 0x567ef0 0701
-primos[56]: 0x567f10 0d01
-primos[57]: 0x567ff0 0f01
-primos[58]: 0x567f60 1501
-primos[59]: 0x567e60 1901
-primos[60]: 0x568000 1b01
-primos[61]: 0x567f20 2501
-primos[62]: 0x567f90 3301
-primos[63]: 0x568010 3701
-primos[64]: 0x568020 3901
-primos[65]: 0x567e80 3d01
-primos[66]: 0x567f40 4b01
-primos[67]: 0x567f50 5101
-primos[68]: 0x568030 5b01
...

y donde se presenta el problema es la siguiente:

Código [Seleccionar] Expandir

-primos[372]: 0x568520 f509
-primos[373]: 0x568560 f709
-primos[374]: 0x5682c0 fd09
-primos[375]: 0x5683f0 130a
-primos[376]: 0x5682b0 1f0a
-primos[377]: 0x568570 210a
-primos[378]: 0x5681e0 310a
-primos[379]: 0x568390 390a
-primos[380]: 0x5683e0 3d0a
-primos[381]: 0x5681f0 490a
-primos[382]: 0x568330 570a
-primos[383]: 0x5683a0 610a
...


¿Nada anormal? Claro esa salida esta bien, el problema esta al guardar el archivo en ese ultimo segmento queda asi (Salida hexadecimal)

Código [Seleccionar] Expandir

F509F709FD09130D0A1F0D0A210D0A310D0A390D0A3D0D0A490D0A570D0A610D0A630D0A670D0A6F0D0A750D0A7B0D0A7F0D0A810D0A850D0A8B0D0A930D0A970D0A990D0A9F0D0AA90D0AAB0D0AB50D0ABD0D0AC10D0ACF0D0AD90D0AE50D0AE70D0AED0D0AF10D0AF30D0A030B110B150B1B0B

Ahora que lo veo Noto un recurrente 0D y no tengo ni idea de donde sale, el detalle no veo error en donde se guarda el archivo repito:

Código (c) [Seleccionar] Expandir

debug("-primos[%i]",primos[offset]->valor,primos[offset]->bytes,offset);
fwrite(primos[offset]->valor,primos[offset]->bytes,1,file);

En teoría lo que se muestra en la salida estándar y en el archivo creado debería de ser lo mismo primos[offset]->valor

Si a alguien le a pasado algo similar o de plano ve un error que yo no veo por favor avíseme.

No creo que sa detalle del sistema, el error se me presenta tanto en FreeBSD y en Windows

¿Que es el contenido de estos archivos?

1
2

Saludos!

Este post es totalmente offtopic del foro de Programacion C/C++

Las discuciones entre programadores que giran en torno al lenguaje C y sus derivados siempre son por temas un tanto tontos como si:

Código (c) [Seleccionar] Expandir

void funcion() {
}

Código (c) [Seleccionar] Expandir

void funcion()
{
}

Que si espacio o tabulador, que si funciones o metodos que si unsigned o signed, que si new o malloc, que si malloc o calloc en fin..

Cuando aprendi programación iniciamos con orientado a objetos y despues ejemplos en C estandar y me agradaban mas los ejemplos sencillos en C, me gustaba tener mas control de la memoria y programar a mas bajo nivel.

A muchos no les gusta o no entienden los punteros o que se yo tal vez vienen de algun lenguaje de mas alto nivel cómo VB o de algun lenguaje script donde no se preocupan tanto por la memoria o los tipos de datos.

He aprendido muchos lenguajes tanto VB como C sharp, Java, Ensamblador, PHP, y varios lenguajes script puedo decir que todos tienen sus pro y sos contra, aun asi NO me canso de programar en C, hay veces que he tenido fricciones con compañeros por la forma en la que programo me dicen usa esto o has esto y la verdad yo nunca les he dicho com programar en fin...

Yo prefiero usar Tabuladores para separar.

¿Tienen ustedes fricciones por como programan o alguna vez le han dicho a alguien mas que mejor use una función u otra?

[Números de longitud variable en C (Numeros muy grandes)]

En su momento mas de alguno uso el operador modulo

r = a % n;

donde r es el resto de la división a/n donde n != 0

Ahora como estoy trabajando con numeros muy grandes de longitud variable el operador modulo como tal no me sirve, necesito crear la funcion que haga el modulo manualmente.

Si alguno de ustedes se perdio los temas, estos son algunos de ellos

Números de longitud variable en C (Numeros muy grandes)
Restas manuales en "Binario"

Ahora si hacemos la funcion modulo en forma de restas, tenemos solo le tenemos que restar al numero a el valor de n hastra que a sea menor que n

El siguiente codigo es muestra de ello de forma manual y sin ninguna optimizacion.

Código (c) [Seleccionar] Expandir

#include<stdio.h>

int main() {
int resto,a,n,contador;
a = 9999998;
n = 3;
resto = a;
contador = 0;
while(resto >= n) {
resto-= n;
contador++;
}
printf("resto: %u\nVeces en el ciclo %u\n",resto,contador);
}

Salida:

Código [Seleccionar] Expandir

resto: 2
Veces en el ciclo 3333332


Como vemos el numero de veces que entra al ciclo es el resultado de la división obtenido de forma iterativa mediante restas sucesivas.

Pero como se trata solo de la función "Modulo" o "Resto" no nos interesa el resultado de la división, para fines prácticos y rápidos realice esa función un poco mas optimizada y se podría optimizar mas, pero ya lo dejo a su consideración.

Código (c) [Seleccionar] Expandir

#include<stdio.h>

int main() {
int resto,a,n,contador,n_pivote,resto_pivote,entrar;
a = 9999998;
n = 3;
resto = a;
contador = 0;
resto_pivote = resto;
n_pivote = n;
entrar = 1;
while(entrar && resto >= n) {
resto_pivote-=n_pivote;
if(resto_pivote>=0) {
resto = resto_pivote;
n_pivote*=2;
}
else {
if(n_pivote > n) {
n_pivote/=2;
resto_pivote = resto;
}
else {
entrar = 0;
}
}
contador++;
}
printf("resto: %u\nVeces en el ciclo %u\n",resto,contador);
}

Salida:

Código [Seleccionar] Expandir


resto: 2
Veces en el ciclo 65


Como vemos el numero de veces que entra es muchísimo menor incluso si optimizamos mas la función para este ejemplo podremos llegar hasta solo 55 o 58 veces entrando al ciclo dado.

El programa utilizada una aproximación binaria ya que en cada iteracion al numero a se le resta un valor igual a n*2 veces la cantidad del ciclo anterior.

Dado que estoy trabajando con numero descomunalmente grandes... cualquier optimizan en estas funciones es mas que bien recibida.

Saludos!



Optimize aun mas el Código y ahora solo se ejecuta 42 veces para el ejemplo dado.

Ahora en lugar de incrementar el sustraendo dentro del ciclo principal lo incremento al máximo en un ciclo aparte antes del principal y posteriormente dentro del ciclo principal lo decremento hasta que sea el un multiplo de n inmediamtamente menor al valor actual de r

Código (c) [Seleccionar] Expandir

#include<stdio.h>

int main() {
int resto,a,n,contador,n_pivote,entrar;
a = 9999998;
n = 3;
resto = a;
contador = 0;
n_pivote = n;
entrar = 1;
while(n_pivote<resto) {
n_pivote+=n_pivote;
contador++;
}
while(entrar && resto >= n) {
while(n_pivote>resto && n_pivote>n) {
n_pivote/=2;
contador++;
}
resto-=n_pivote;
}
printf("resto: %u\nVeces en el ciclo %u\n",resto,contador);
}

Salida:

Código [Seleccionar] Expandir

resto: 2
Veces en el ciclo 42


Considero yo que es el mas optimizado pero no se tal vez se puede ahorrar alguno que otro ciclo, la variable contador solo es para fines didácticos.

Saludos

Muy buen dia compañeros.

Ayer publique el tema Números de longitud variable en C (Numeros muy grandes)

Donde transformo strings de numeros a su representación en "binario"  en memoria. Ya hago sumas y multiplicaciones en forma de sumas multiples.
Necesito hacer ahora restas tengo mis dudas se que es una tonteria pero estoy hecho un lio.

Las sumas a nivel de "byte" las hago asi:

Código (c) [Seleccionar] Expandir

unsigned char resultado[3];
unsigned char acarreo;
unsigned char a;
unsigned char b;
unsigned short c;
a = 0xFF;
b = 0x01;
c = a + b;
//ahora c vale 0x0101
resultado[0] = c;
acarreo = c >> 8;
//el acarreo se le suma al siguiente ciclo de bytes

Asi puedo meter ese seudo codigo en un ciclo de N bytes y poder trabajar con numetro positivos de cualquier longitud

Ahora el detalle que necesito usar la operacion modulo y para ello necesito hacer diviciones y por lo tante necesito restas.

Mi duda es hacer las restas mas o menos igual

Código (c) [Seleccionar] Expandir

#include<stdio.h>

int main() {
unsigned char a;
unsigned char b;
unsigned short c;
a = 0xFF;
b = 0x01;
c = a - b;
}


Obvio tendré que tener forma de capturar los números negativos, y si es negativo ¿Que hay que hacer? ¿es como si fuera el acarreo en la suma?

intente hacer las restas en el cuaderno en binario y me dormi en el intento eso fue hace unas 5 horas.

[cualquier longitud]

Y si bien deben de existir varias librerías que ya lo implementen a su manera no me quería quedar sin implementar mi propia solución.

El programa ahora solo convierte cadenas de números decimales "1234" en su representación binaria en memoria, pero no se engañen esta no es la función strtol, esta puede almacenar numeros (sin signo por el momento) de cualquier longitud siempre y cuando tengamos memoria suficiente.

Vamos a ver un ejemplo de las siguientes cadenas:
"1"
"50"
"200"
"255"
"65535"
"4294967295"
"18446744073709551615"

Código (c) [Seleccionar] Expandir

int main() {
numero *n;
n = valor("1"); //Ejemplo de 1 solo digito
free_numero(n);
n = valor("50"); //Ejemplo de 2 digitos
free_numero(n);
n = valor("200"); //Ejemplo de 3 digitos
free_numero(n);
n = valor("255"); //Maximo numero de 1 byte
free_numero(n);
n = valor("65535"); //Maximo numero de 2 bytes
free_numero(n);
n = valor("4294967295"); //Maximo numero de 4 bytes
free_numero(n);
n = valor("18446744073709551615"); //Maximo numero de 8 bytes
free_numero(n);
}

Salida (Con un poco de depuración)

Código [Seleccionar] Expandir

procesando numero 1
1 x10^0 : numeros[0]->valor: 0x456b30 01
b->valor: 0x456bb0 01
procesando numero 50
5 x10^1 : numeros[0]->valor: 0x451480 32
0 x10^0 : numeros[1]->valor: 0x451470 00
b->valor: 0x451530 32
procesando numero 200
2 x10^2 : numeros[0]->valor: 0x451470 c8
0 x10^1 : numeros[1]->valor: 0x4514f0 00
0 x10^0 : numeros[2]->valor: 0x4514b0 00
b->valor: 0x451500 c8
procesando numero 255
2 x10^2 : numeros[0]->valor: 0x451550 c8
5 x10^1 : numeros[1]->valor: 0x451420 32
5 x10^0 : numeros[2]->valor: 0x451530 05
b->valor: 0x451420 ff
procesando numero 65535
6 x10^4 : numeros[0]->valor: 0x451410 60ea
5 x10^3 : numeros[1]->valor: 0x451510 8813
5 x10^2 : numeros[2]->valor: 0x4514a0 f401
3 x10^1 : numeros[3]->valor: 0x451530 1e
5 x10^0 : numeros[4]->valor: 0x4513e0 05
b->valor: 0x451420 ffff
procesando numero 4294967295
4 x10^9 : numeros[0]->valor: 0x4514f0 00286bee
2 x10^8 : numeros[1]->valor: 0x4514a0 00c2eb0b
9 x10^7 : numeros[2]->valor: 0x4514b0 804a5d05
4 x10^6 : numeros[3]->valor: 0x457210 00093d
9 x10^5 : numeros[4]->valor: 0x4571a0 a0bb0d
6 x10^4 : numeros[5]->valor: 0x457160 60ea
7 x10^3 : numeros[6]->valor: 0x457380 581b
2 x10^2 : numeros[7]->valor: 0x456ff0 c8
9 x10^1 : numeros[8]->valor: 0x457230 5a
5 x10^0 : numeros[9]->valor: 0x4572e0 05
b->valor: 0x457210 ffffffff
procesando numero 18446744073709551615
1 x10^19 : numeros[0]->valor: 0x457180 0000e8890423c78a
8 x10^18 : numeros[1]->valor: 0x4572e0 0000203b9db5056f
4 x10^17 : numeros[2]->valor: 0x457370 00002876e1158d05
4 x10^16 : numeros[3]->valor: 0x457390 000004bfc91b8e
6 x10^15 : numeros[4]->valor: 0x457360 0000a7dcf75015
7 x10^14 : numeros[5]->valor: 0x456ff0 00c05773a57c02
4 x10^13 : numeros[6]->valor: 0x457060 0080ca396124
4 x10^12 : numeros[7]->valor: 0x457000 00409452a303
0 x10^11 : numeros[8]->valor: 0x457080 00
7 x10^10 : numeros[9]->valor: 0x457290 003c534c10
3 x10^9 : numeros[10]->valor: 0x457330 005ed0b2
7 x10^8 : numeros[11]->valor: 0x4571a0 0027b929
0 x10^7 : numeros[12]->valor: 0x4571e0 00
9 x10^6 : numeros[13]->valor: 0x457200 405489
5 x10^5 : numeros[14]->valor: 0x4570d0 20a107
5 x10^4 : numeros[15]->valor: 0x457250 50c3
1 x10^3 : numeros[16]->valor: 0x4572a0 e803
6 x10^2 : numeros[17]->valor: 0x457240 5802
1 x10^1 : numeros[18]->valor: 0x457130 0a
5 x10^0 : numeros[19]->valor: 0x457150 05
b->valor: 0x457840 ffffffffffffffff


Ahora esos son ejemplo que las funciones estándar existentes pueden manejar correctamente

Ahora bien el siguiente numero

Código [Seleccionar] Expandir

98765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210

Código (c) [Seleccionar] Expandir

int main() {
numero *n;
n = valor("98765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210"); //Ejemplo de un Googol???
free_numero(n);
}

Salida sin tanta depuración:

Código [Seleccionar] Expandir



procesando numero 98765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210
b->valor: 0x777b70 ea7ec651d7671ed5de67409bdc172dc9a9d7bbd8302306b3a2e2a0cf7730b39b359cea778e3d200b9b9fb6770c6b95b395e8ab9f1474014c01ce7a3e870aa632c1ce5b705dc9f0a328d297dc436038565411ca0e338c7db56f94881768b143402be103d352ddf1beb8d5d3f59c88bb500306744fbfea44dca84d3c2cca5a88060c7168dfa57b5f86a57dda5ad3d0957639100089ca6ac40c6fbc516e76821e8026d3fce0d3fa4b1a5c5b42f723c67c3801e5b6146b5c44a3c70c7b7f63634f14211881cf4fca1bd9f7d9b8bda6db831e0a06f25384fd4262826ba6498c9ec27623314c5d7222d86a9cdf905544e7d67a056bb74b830615b2a164ba237a3889fd302bd8e092456865c265c8202d61ff55a442dc22547e68935d270fa33825e4cd331378afe199ae4ab2acea2aca6330f4727f244b72569ba75bab5a53ce22e2472f603d57314b8b02b361931bcef98c0911032db9e418e9288359f38c1fdfbe7f6a4d2fed867f76fd66d82cd107278f5ae8ec0033a226a31d2e2415f9eb72e910bfad8c2d7c02e8d44c2689de3587e51162308a50fbb776d016ea5491929011176ec8401dbed59282af7910675df3810d704db4faca2e8b44ab92d06237e872c0deef48718f59edd1541f5366e49dcabd9a00c64ec1c99f23be503b0a559e545702185426b2d94b5d7dac547ae430ebac390487d3d80b8b7b7d7d1cd2a40688f96c286cb522671faa5f272e4dd858d3f6bcbdb10fa70bebbef59aa82c18fdfd622c4b7e215c315373e366e84e0a
el numero necesita 557 bytes



Falta optimizar las funciones, el proceso de multiplicación lo hace mediante sumas continuas, trate de liberar la memoria con forme se va usando para no olvidar ninguna variable pero se me pudo pasar alguna.

Usos que se le pueden dar al programa
Si necesitas algo especializado y almacenar números extremadamente grandes para su posterior uso esta es una buena forma de hacerlo.
Yo en lo personal trabaje con esta aplicación por que necesito una forma de almacenar números de mas de 4096 bits tengan encuenta que en el ejemplo anterior el numero mas grande fue un numero de 557 bytes que son 4456 bits.
El proceso mas tardado es convertir el numero de string a binario. Posteriormente considero que las sumas son algo eficientes cuando los números ya se encuentran en su representación binaria.

Codigo completo:

Código (c) [Seleccionar] Expandir

/*
Twitter @albertobsd
*/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdarg.h>

typedef unsigned char byte;

typedef struct numero_struct {
byte *valor;
unsigned int bytes;
}numero;

numero *valorBase10(unsigned char n,unsigned char e);
numero *valor(char *n);
unsigned short add(unsigned char a, unsigned char b);
void debug(char*s,unsigned char *ptr,unsigned int l,...);
numero *add_numero(numero *a,numero *b);
numero *copiar(numero* n);

numero *add_numero(numero *a,numero *b) {
numero *c;
unsigned char flag_a = 1,flag_b = 1,valor_a,valor_b,acarreo;
unsigned short valor_c;
unsigned int i = 0,max,entrar =1;
//printf("add_numero\n");
//debug("a->valor",a->valor,a->bytes);
//debug("b->valor",b->valor,b->bytes);
c = calloc(sizeof(numero),1);
max = a->bytes + b->bytes;
c->valor = calloc(max,1);
//printf("while\n");
while(entrar) {
valor_c = 0;
//printf("valor de i: %u\n",i);
//printf("valor de a->bytes: %u\n",a->bytes);
if(i < a->bytes) {
valor_a = a->valor[i];
}
else {
flag_a = 0;
valor_a = 0;
}
//printf("valor de b->bytes: %u\n",b->bytes);
if(i < b->bytes) {
valor_b = b->valor[i];
}
else {
flag_b = 0;
valor_b = 0;
}
if(flag_a || flag_b) {
if(c->valor[i] != 0) {
//printf("valor de c->valor[%i]: 0x%.2x\n",i,c->valor[i]);
valor_c+=c->valor[i];
c->valor[i] = 0;
}
//printf("valor de valor_a: 0x%.2x\n",valor_a);
//printf("valor de valor_b: 0x%.2x\n",valor_b);
valor_c+= add(valor_a,valor_b);
//printf("valor de valor_c: 0x%.4x\n",valor_c);
c->valor[i] = valor_c;
acarreo = valor_c >> 8;
i++;
if(acarreo) {
//printf("valor de acarreo: 0x%.2x\n",acarreo);
c->valor[i] = acarreo;
//printf("valor de c->valor[%i]: %.2x\n",i,c->valor[i]);
}
}
else {
entrar = 0;
}
}
//printf("end while\n");
if(acarreo) {
c->bytes = i+1;
}
else {
c->bytes = i;
}
//printf("bytes: %i\n",c->bytes);
//debug("c->valor",c->valor,c->bytes);
//printf("End add_numero\n");
return c;
}

void free_numero(numero* t) {
if(t) {
if(t->valor) {
memset(t->valor,0,t->bytes);
free(t->valor);
}
memset(t,0,sizeof(numero));
free(t);
}
}

numero *copiar(numero* n) {
numero *t;
t= calloc(sizeof(numero),1);
t->bytes = n->bytes;
t->valor = calloc(t->bytes,1);
memcpy(t->valor,n->valor,t->bytes);
return t;
}

void debug(char *s,unsigned char *ptr,unsigned int l,...) {
va_list args;
int i = 0;
char *buffer;
buffer = calloc(strlen(s)*10,sizeof(char));
va_start(args, l);
vsprintf(buffer,s, args);
printf("%s: 0x%x ",buffer,ptr);
while(ptr && i < l) {
printf("%.2x",ptr[i++]);
}
printf("\n");
va_end(args);
free(buffer);
}

numero *valorBase10(unsigned char n,unsigned char e) {
int i,j;
numero *a,*b,*t,*zero,**tofree;
a = calloc(sizeof(numero),1);
a->bytes = 1;
a->valor = calloc(a->bytes,1);
a->valor[0] = n;
zero = calloc(sizeof(numero),1);
zero->bytes = 1;
zero->valor = calloc(zero->bytes,1);
zero->valor[0] = 0;
b = zero;
i = 0;
while(i< e) {
j = 0;
tofree = calloc(sizeof(numero*),10);
while(j < 10) {
t = add_numero(a,b);
tofree[j++] = t;
b = t;
}
free_numero(a);
a = copiar(b);
j = 0;
while(j<10) {
free_numero(tofree[j++]);
}
free(tofree);
b = zero;
i++;
}
free_numero(b);
return a;
}

numero *valor(char *n) {
numero *zero,*b;
numero **numeros;
char *ptr;
int bytes;
int i,j;
printf("procesando numero %s\n",n);
ptr = n;
bytes = strlen(n);
numeros = calloc(sizeof(numero*),bytes);
i = 0;
while(i < bytes) {
numeros[i] = valorBase10(ptr[i] - '0' , (bytes-1) - i);
//debug("numeros[i]",(unsigned char*)numeros[i],sizeof(numero));
//debug("%c x10^%i : numeros[%i]->valor",(unsigned char*)numeros[i]->valor,numeros[i]->bytes,ptr[i],(bytes-1) - i,i);
i++;
}
zero = calloc(sizeof(numero),1);
zero->bytes = 1;
zero->valor = calloc(zero->bytes,1);
zero->valor[0] = 0;
b = zero;
i = 0;
while(i < bytes) {
b = add_numero(numeros[i],b);
free_numero(numeros[i]);
i++;
}
//debug("b",(unsigned char*)b,sizeof(numero));
debug("b->valor",(unsigned char*)b->valor,b->bytes);
free(zero);
return b;
}
unsigned short add(unsigned char a, unsigned char b) {
return a+b;
}
int main() {
numero *n;
n = valor("1"); //Ejemplo de 1 solo digito
free_numero(n);
n = valor("50"); //Ejemplo de 2 digitos
free_numero(n);
n = valor("200"); //Ejemplo de 3 digitos
free_numero(n);
n = valor("255"); //Maximo numero de 1 byte
free_numero(n);
n = valor("65535"); //Maximo numero de 2 bytes
free_numero(n);
n = valor("4294967295"); //Maximo numero de 4 bytes
free_numero(n);
n = valor("18446744073709551615"); //Maximo numero de 8 bytes
free_numero(n);
n = valor("98765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210"); //Ejemplo de un Googol???
printf("el numero necesita %i bytes\n",n->bytes);
free_numero(n);
}

[Solucion]

Estoy buscando una solucion simplo como

Código (php) [Seleccionar] Expandir

json_encode

pero en ASP.net ya se C# o VB


Solucion

Código (csharp) [Seleccionar] Expandir

JavaScriptSerializer serie = new JavaScriptSerializer();
lista = serie.Serialize(Objeto);

Código (vbnet) [Seleccionar] Expandir

Imports System.Web
Imports MySql.Data.MySqlClient

Pues eso donde tengo que colocar las sentecias imports dentro del documento aspx?

Estoy usando Visual Studio Express 2015

Saludos.



Solucion

en el archivo defualt.aspx tiene que estar la primera linea debe de decir al como:

Código (vbnet) [Seleccionar] Expandir

<%@ Page Language="vb" AutoEventWireup="false" CodeBehind="default.aspx.vb" Inherits="WebApplication5.WebForm1" %>
Entonces debe exister un archivo llamado defualt.aspx.vb

Ahi tenemos que colocar las sentecias

Muy buen dia compañeros, yo realmente prefiero las soluciones en algun otro lenguaje como PHP pero.... me estan pidiendo trabajar en ASP.NET

Me he topado al tratar de ejcutar un codigo sencillo de ejemplo de la siguiente pagina

http://www.w3schools.com/aspnet/razor_syntax.asp

Código (csharp) [Seleccionar] Expandir


<!-- Single statement block -->
@{ var myMessage = "Hello World"; }

<!-- Inline expression or variable -->
<p>The value of myMessage is: @myMessage</p>

<!-- Multi-statement block -->
@{
var greeting = "Welcome to our site!";
var weekDay = DateTime.Now.DayOfWeek;
var greetingMessage = greeting + " Here in Huston it is: " + weekDay;
}
<p>The greeting is: @greetingMessage</p>


Al momento de cargar en la URL en el navegaor me dice que:

http://localhost/test.cshtml

Código [Seleccionar] Expandir


Server Error in '/' Application.

This type of page is not served.

Description: The type of page you have requested is not served because it has been explicitly forbidden.  The extension '.cshtml' may be incorrect.   Please review the URL below and make sure that it is spelled correctly.

Requested URL: /test.cshtml

Version Information: Microsoft .NET Framework Version:4.0.30319; ASP.NET Version:4.0.30319.34209



He googleado bastante y no he encontrado solucion al problema.

Tengo el IIS instaldo y el codigo lo pongo desde el block de notas en el directorio correspondiente.
Uso windows 8.1 en este momento.

Tengo bastante sin usar windows aun asi no he encontrado la configuracion correspondiente para ejcutar esos codigos.

Si escribo ejemplo de codigo de ASP clasico si los ejecuta, incluso algunos codgios de .net en VB y C# tambien pero el anterior no lo ejecuta para nada.

La publicación original la tengo en mi pagina:

http://codigoenc.com/post/33/Juego_de_BlackJack_en_C_paso_a_paso

El juego se puede optimazar si. Se puede perzonalizar si, actualmente juega en automatico.



En este Topic vamos a hacer un juego de blackjack en C, lo vamos a tratar de ser lo mas sencillo posible explicando función por función.


Primero definiremos un Maso de cartas esto es 13 cartas desde el A hasta el K

Código (c) [Seleccionar] Expandir

char *mazo = "A234567890JQK";

Para hacer este juego lo mas escalable posible generaremos dinámicamente un mazo de juego de N bajaras, para eso tenemos la siguiente función:

Código (c) [Seleccionar] Expandir

char *crear_baraja(int n) {
int i = 0,j;
int offset = 0;
char *cartas;
cartas = calloc(sizeof(char)*52+1,n);
while(i < n) {
j = 0;
while(j < 4) {
memcpy(cartas+offset,mazo,13);
offset+=13;
j++;
}
i++;
}
cartas[offset] = '\0'; //Esta instrucción es innecesaria debido a la función calloc pero lo dejamos para aclarar que nuestra condicion de paro es el caracter nulo al final de la cadena
return cartas;
}

La funcion anterior solo nos devuelve un puntero con la memoria asignada mediante Malloc con la cantidad de bajaras que le pedimos.

Ahora si mandamos a llamar esta funcion y mostramos la cadena veremos un mazo ordenado obvio por la forma que se construyo
En este ejemplo usaremos 2 barajas pero tengan en cuenta que puede ser hasta 1000 barajas siempre y cuando este disponible

Código (c) [Seleccionar] Expandir

baraja = crear_baraja(2);
printf("Baraja:\n%s\n",baraja);
salida:

Código [Seleccionar] Expandir


Baraja:
A234567890JQKA234567890JQKA234567890JQKA234567890JQKA234567890JQKA234567890JQKA234567890JQKA234567890JQK


Ahora si bien tenemos que barajar la bajara.

Código (c) [Seleccionar] Expandir

char *barajar(char *baraja) {
int len = strlen(baraja);
char *temp = calloc(len+1,1);
int r;
int i = 0;
/*
Poner su propia funcion random disponible en su sistema
En freeBSD prefiero usar arc4rand
*/
while(i < len) {
r = arc4random_uniform(len);
if(baraja[r] != 0) {
temp[i] = baraja[r];
baraja[r] = 0;
i++;
}
}
free(baraja);
return temp;
}

Esta función nos devuelve un nuevo puntero con la bajara anterior pero ahora en desorden

Mostramos la salida:

Código (c) [Seleccionar] Expandir

baraja = barajar(baraja);
printf("Baraja:\n%s\n",baraja);

Código [Seleccionar] Expandir

Baraja:
9KJ4067Q6A9068Q5A08J3Q3QJ7Q3AK38A6J453762KK0852KA4Q52548753Q234A42K2Q3J7KJ090A62A5J0674KJ702689799989584

Depues de construir las funcoines de evaluar carta y evaluar jugador podemos terminar el juego

Código (c) [Seleccionar] Expandir


/*
Twitter @albertobsd
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
/*
Maso basico de Cartas para su salida en pantalla.
el 0 vale representa a la carta 10
*/
typedef struct jugador_struct {
int continuar;
int valor;
int offset;
char mano[6];
}jugador;

char *mazo = "A234567890JQK";

char *crear_baraja(int n);
char *barajar(char *baraja);
int juego(char *bajara,int *offset,int m);
void evaluar_jugador(jugador *j);
int evaluar_carta(char c);
void debug(char *p,int l);

int main() {
char *baraja;
int offset = 0;
printf("Juego de BlackJack\n");
printf("Creando bajara...\n");
baraja = crear_baraja(2);
printf("Baraja:\n%s\n",baraja);
printf("Revolver bajara...\n");
baraja = barajar(baraja);
printf("Baraja:\n%s\n",baraja);
juego(baraja,&offset,6); // La casa juega contra 6 Jugadores Solo una ronda, si queremos mas rondas tendremos que agregarlo en un ciclo y controlar el numero de cartas restantes en la baraja
free(baraja);
}

char *crear_baraja(int n) {
int i = 0,j;
int offset = 0;
char *cartas;
cartas = calloc(sizeof(char)*52+1,n);
while(i < n) {
j = 0;
while(j < 4) {
memcpy(cartas+offset,mazo,13);
offset+=13;
j++;
}
i++;
}
cartas[offset] = '\0'; //Esta instruccion es incesaria debido a la funcion calloc
return cartas;
}

char *barajar(char *baraja) {
int len = strlen(baraja);
char *temp = calloc(len+1,1);
int r;
int i = 0;
/*
Poner su propia funcion random disponible en su sistema
En freeBSD prefiero usar arc4random_uniform
*/
while(i < len) {
r = arc4random_uniform(len);
if(baraja[r] != 0) {
temp[i] = baraja[r];
baraja[r] = 0;
i++;
}
}
free(baraja);
return temp;
}

int juego(char *bajara,int *offset,int m) {
int len = strlen(bajara);
int i = offset[0],j = 0,k = 0, n = m+1;
jugador **jugadores;
jugadores = calloc(sizeof(jugador*),n);
//memset(jugadores,0,sizeof(jugador)*2);
/* Generamos n jugadores (m jugadores elegidos por el usuario + la casa jugador 0) */
/* Repartimos Cartas a todos los jugadores*/
while(k < n) {
jugadores[k] = calloc(sizeof(jugador),1);
printf("Memoria asignada para el jugador %i @ 0x%X [%i bytes]\n",k,jugadores[k],sizeof(jugador));
k++;
}
while( j < 2 ) {
k = 0;
while(k < n) {
jugadores[k]->mano[j] = bajara[i];
jugadores[k]->offset++;
i++;
k++;
}
j++;
}
/* Funcion de depuracion
debug(jugadores[0],16);
debug(jugadores[1],16);
*/
/*
Aqui se ve la mano de cada jugador en el proximo printf dentro del ciclo solo es para fines didacticos
posteriormente solo se evaluan las manos;
*/
j = 0;
while( j < n ) {
printf("Jugador: %i\ncartas %s\n",j,jugadores[j]->mano);
evaluar_jugador(jugadores[j]);
printf("Valor actual: %i\n",jugadores[j]->valor);
j++;
}
/*
Despues de repartir las cartas los jugadores juegan y la casa se destapa al final
*/
j = 1;
while( j < n ) {
while(jugadores[j]->continuar) {
jugadores[j]->mano[jugadores[j]->offset] = bajara[i];
//printf("Jugador: %i\ncartas %s\n",j,jugadores[j]->mano);
jugadores[j]->offset++;
evaluar_jugador(jugadores[j]);
i++;
}
j++;
}
/*
Ahora juega la casa.
*/
while(jugadores[0]->continuar) {
jugadores[0]->mano[jugadores[0]->offset] = bajara[i];
jugadores[0]->offset++;
evaluar_jugador(jugadores[0]);
i++;
}
/* Mostramos a todos los resultados*/
j = 1;
while( j < n ) {
printf("Jugador: %i\ncartas %s\n",j,jugadores[j]->mano);
printf("Valor actual: %i\n",jugadores[j]->valor);
if(jugadores[j]->valor > 21) {
printf("Perdio\n");
}
else {
if(jugadores[j]->valor == 21) {
printf("Gano BlackJack\n");
}
else {
if(jugadores[0]->valor > 21) {
printf("Gano\n");
}
else {
if(jugadores[j]->valor > jugadores[0]->valor) {
printf("Gano\n");
}
else {
printf("Perdio\n");
}
}
}
}
j++;
}

/*
Liberamos memoria de los jugadores
*/
while( j < n ) {
free(jugadores[j]);
j++;
}
/*
Retornamos el valor actaul del offset mediante la direccion de memoria del argumento.
y Retornamos el jugador ganador;
*/
offset[0] = i;
return 1;
}

void evaluar_jugador(jugador *j) {
int i = 0;
char v;
j->valor = 0;
while(j->mano[i] != 0) {
v = evaluar_carta(j->mano[i]);
if(v == 1) {
if((j->valor + 11) <= 21 ) {
j->valor += 11;
}
else {
j->valor += v;
}
}
else {
j->valor += v;
}
if(j->valor <= 16) {
j->continuar = 1;
}
else {
j->continuar = 0;
}
i++;
}
}

int evaluar_carta(char c) {
int r = 0;
switch(c) {
case 'A':
r = 1;
break;
case 'K':
case 'Q':
case 'J':
case '0':
r = 10;
break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
r = c - '0';
break;
}
return r;
}

void debug(char *p,int l) {
int i = 0;
printf("0x%x\n",p);
while(i < l) {
printf("%.2x",p[i]);
i++;
}
printf("\n");
}


Salida completa

Código [Seleccionar] Expandir

Juego de BlackJack
Creando bajara...
Baraja:
A234567890JQKA234567890JQKA234567890JQKA234567890JQKA234567890JQKA234567890JQKA234567890JQKA234567890JQK
Revolver bajara...
Baraja:
57A6627296K55Q4Q0073Q2K4J6J297A962AK40350J87754369JJ3JJ7AJQ20828A9A5K0528K8549K9Q0AKK69604487Q38843Q33AQ
Memoria asignada para el jugador 0 @ 0x2880D040 [20 bytes]
Memoria asignada para el jugador 1 @ 0x2880D060 [20 bytes]
Memoria asignada para el jugador 2 @ 0x2880D080 [20 bytes]
Memoria asignada para el jugador 3 @ 0x2880D0A0 [20 bytes]
Memoria asignada para el jugador 4 @ 0x2880D0C0 [20 bytes]
Memoria asignada para el jugador 5 @ 0x2880D0E0 [20 bytes]
Memoria asignada para el jugador 6 @ 0x2880D100 [20 bytes]
Jugador: 0
cartas 52
Valor actual: 7
Jugador: 1
cartas 79
Valor actual: 16
Jugador: 2
cartas A6
Valor actual: 17
Jugador: 3
cartas 6K
Valor actual: 16
Jugador: 4
cartas 65
Valor actual: 11
Jugador: 5
cartas 25
Valor actual: 7
Jugador: 6
cartas 7Q
Valor actual: 17
Jugador: 1
cartas 794
Valor actual: 20
Gano
Jugador: 2
cartas A6
Valor actual: 17
Perdio
Jugador: 3
cartas 6KQ
Valor actual: 26
Perdio
Jugador: 4
cartas 650
Valor actual: 21
Gano BlackJack
Jugador: 5
cartas 250
Valor actual: 17
Perdio
Jugador: 6
cartas 7Q
Valor actual: 17
Perdio

Estaba viendo que Google ofrece un periodo de prueba para su nube.

La pregunta es ¿Alguno lo a usado? estoy apunto de subir uno de mis proyectos a ella, mi preocupacion es el costo del uso del ancho de banda y el almacenamiento, he visto la calculadora de precios estimados pero me gustaria conocee la experiencia de alguno de ustedes

Estoy programando un nuevo bot, el anterior que hice es un bot para administrar clientes de un programa torrent esro fue un proyecto personal, pero ahora busco un uso mas generico el bot estaria accesible a todo el publico y haria cosas.

Estoy pensando en darle usos informaticos/hacking por ejemplo se me ocurre realizar:

• Consultas DNS
• Mostar la salida estandar de Nmap escaneando una IP publica
• Servir de proxie
• Mandar mensjaes SMS de Emergencia 1x dia x usuario

Alguna otra idea?

o Mejor aun, que seria util para ustedes recibir de informacion diario en su telefono de forma inmediata.

No lo quiero hacer de noticias ya que ellos abundan.

Estoy leyendo un reporte sobre Qbot suena bastante interesante, ¿alguien tiene mas info sobre las tecnicas utilizadas?

https://threatpost.com/qbot-malware-morphs-quickly-to-evade-detection/117377/

[Cifrar y descifrar la eterna lucha]

Cifrar y descifrar la eterna lucha.

Lista de Decrypter:

• Petya

Si bien la llegada al Internet de un nuevo malware de la clase de los ransomware no es nada nuevo.

Lo que es motivo de celebrar es que cada vez mas se escucha sobre herramientaa que decrifran los archivos sin nececidad de pagar a los ciber-extorcionadores.

Leyendo hoy las noticias salta que ya hay metodo conocido para recuperar el MBR infectado por PETYA esta.

¿Falla de Petya?
Dejar las llaves de decifrado en el disco duro.

Petya se caracteriza por dejar intactos los archivos pero inhabilitar el acceso a la computadora pidiendo pago a cambio de la clave.

Si bien este tipo de tecnica (alterar el MBR) era mas conocida hace una o dos decadas debido al gran flujo de uso de diskttes ya que eran mas propensos a infectarse de ese tipo de virus de arranque. Pues la tecnica volvio con PETYA, si bien ya sea por flojera de utilizar alguna libreria para el cifrado o facilidad de implementar codigo en ensamblador para modificar el MBR

Se cometio la pereza de dejar la llave en el disco.

¿Como se puede mejorar PETYA?
Implementar algunas rutinas critograficas en ensamblador.
Creo que para este tipo de ransomware no es vital utilizar llaves RSA de gran cantidad de bits asi que implementar algo utilizando una menor cantidad de bits no parace mala idea.

La otra y mas importante es No dejar las llaves en el disco duros si bien este ha sido el talon de Aquiles de muchos ransomwares mal diseñados, parece ser que dada la vida tan corta que tienen los servidores de control dejar las llaves en el disco a sido necesario.

[¿Cual es la mejor forma de generar un ID?]

Buen dia.

¿Cual es la mejor forma de generar un ID?

Les dejo mi metodo y si ustedes tienen otro podria ser muy didactivo explicarlo por aqui

En el proyecto en el que estoy trabajando necesita generar un ID por usuario que instale la aplicacion.

-Muiltiplataforma
-Comunicacion cifrada end-to-end (Lo que esta de moda)

En fin el programa genera  un unico par de claves RSA para la criptografia asimetrica y genero llaves aleatorias para la criptografia simetrica en fin...

Genero un sha512 iterativo N cantidad de veces (mas de 4000) del archivo de la clave publica y este devuelve 64 bytes. Esta es mi ID del usuario y en teoria  no deberia de repetirse nuca...  

Tal como lei en el documento de whatsapp ellos hacen una conversion solo de los ultimos 30 bytes de la clave y luego pasan cada 5 bytes a un entero sin signo y a ese entero le sacan modulo 100000.

Yo por mi parte copio de 8 en 8 bytes al entero sin signo:

Código (c) [Seleccionar] Expandir


int main() {
int j;
unsigned char *temp;
unsigned long long t;
temp = md_file(GCRY_MD_SHA512,"llavePublica");
j = 0;
printf("ID: ");
while(j < 64) {
printf("%.2x",temp[j++]);
}
printf("\n");
printf("long long :%i\n",sizeof(unsigned long long));
j = 0;
t = 0;
while(j < 8) {
memcpy(&t,temp + (j*8),8);
printf("%llu\n",t);
t = 0;
j++;
}
free(temp);
}


Salida:

Código [Seleccionar] Expandir


ID: d97a302e486bd15f55d4a2e6f7eba511042b0ee4ae118596584393e002103dd65e9d1c822963d945e17d4c24d9b7b6ad0fd54a7a03acea32bf899e22c7c0576b
long long :8
6904417661492427481
1271681919760913493
10846094720439823108
15437512702239654744
5033163088490962270
12517394357567651297
3668933977383294223
7734862846543956415


[TEMA REPETIDO]

Bueno como es noticia desde hace unas horas para algunos usuarios, whatsapp en sus nueva actualizacion acaba de anunciar que implementara cifrado end-to-end.

El documento explicando todo el proceso esta disponible para su lectura en

https://s3-eu-west-1.amazonaws.com/uploads-eu.hipchat.com/83000%2F605209%2FM79CMVvVjjbGFRx%2FWhatsApp-Security-Whitepaper.pdf

En general usan un par de claves Curve25519

agregare algunos comentarios en lo que tenga mas oportunidad.

TEMA REPETIDO

LEER: https://foro.elhacker.net/noticias/whatsapp_ya_es_100_seguro_con_cifrado_end_to_end-t450517.0.html

Buen dia compañeros.

Quiero compartirles el proyecto en el que estoy trabajando.

Una interfaz en C para que programen su bot para telegram.

El codigo esta disponible en github, aun lo sigo mejorando y optimizando lo mas que pueda.
Casi todo el programa es memoria dimanica la cual  administra muy bien la aplicacion.

Ejemplo de uso.

Código (c) [Seleccionar] Expandir


/*
* Luis Alberto
* Twitter @albertobsd
*/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<curl/curl.h>
#include<sys/stat.h>
#include<errno.h>
#include"telegram.h"
#include"jsmn.h"

int main() {
Updates *updates;
User *user;
Message *message;
File *file;
char **variables;
char **valores;
int i = 0;
char *filename;
telegram_init("123456789:zwxecrvtbynuyvbnmutyguhjdkeosdgjhfdouhn");
user = telegram_getMe();
if(!telegram_is_error()) {
printf("User: id: %i\nusername: %s\n",user->id,user->username);
telegram_free_user(user);
}
else {
printf("%s\n",telegram_get_error());
}
updates = telegram_getUpdates();
if(!telegram_is_error()){
printf("updates: %i\n",updates->length);
while(i < updates->length) {
if(updates->list[i]->item.message->document) {
printf("Document exits file_id : %s\n",updates->list[i]->item.message->document->file_id);
file = telegram_getFile(updates->list[i]->item.message->document->file_id);
if(!telegram_is_error()) {
filename = telegram_downloadFile(file,updates->list[i]->item.message->document->file_name);
printf("file name : %s\n",filename);
}
else {
printf("%s\n",telegram_get_error());
}
}
i++;
}
telegram_free_updates(updates);
}
else {
printf("%s\n",telegram_get_error());
}
variables = calloc(5,sizeof(char*));
valores = calloc(5,sizeof(char*));
variables[0] = "chat_id";
variables[1] = "text";
valores[0] = "9219883";
valores[1] ="Texto de prueba";
message = telegram_sendMessage(telegram_build_post(variables,valores));
if(!telegram_is_error()) {
printf("OK %s\n",message->text);
telegram_free_message(message);
}
else {
printf("%s\n",telegram_get_error());
}
variables[1] = "caption";
valores[1] = "Envio archivo";
message = telegram_sendDocument("test_telegram",variables,valores);
if(!telegram_is_error()) {
printf("OK %s\n",message->text);
telegram_free_message(message);
}
else {
printf("%s\n",telegram_get_error());
}
return 0;
}




Para trabajar con este ejemplo tenemos que te generar un token de autorización para nuestro bot y editar la linea de codigo:

Código (c) [Seleccionar] Expandir

telegram_init("123456789:zwxecrvtbynuyvbnmutyguhjdkeosdgjhfdouhn");

en este ejemplo procesamos las peticiciones:

getMe
getUpdates
sendDocument

Tambien que tenemos que sustituir el chat_id por el nuestro
El codigo depende de que tengamos instalado libcurl

Codigo en gihub

https://github.com/albertobsd/libtelegrambot

Saludos!

[Creacion de par de Claves RSA]

Muy buen dia, este sera un pequeño taller para entender un poco mas sobre criptografía paso a paso usando lenguaje C y la libreria Libgcrypt.

Nota para el moderador Lo pongo en Cryptografia  y no en C/C++ por ver el detalle de los conceptos criptograficos.

Asi podremos observar paso paso el contenido de la memoria  y como esta cambia.

Antes de programar con libgcrypt yo solo sabia los conceptos básicos de Criptografia pero en general desconocía a grandes rasgos la forma interna de trabajar de programas como GnuPG entre otros.

Los códigos que pondré aqui estan a su disposición para practicar con la librería y los conceptos criptográficos y estan disponibles en github

https://github.com/albertobsd/libgcrypt-examples

Creacion de par de Claves RSA

Bien el primer tema sera crear una clave RSA de cierta cantidad de bits y ver como esta esta clave en la memoria.

El primer ejemplo esta bajo el nombre RSA_2048.c aunque en realidad el ejmplo crea un par claves de 4096 bits
https://github.com/albertobsd/libgcrypt-examples/blob/master/RSA_2048.c

El programa genera un nuevo par de claves RSA de 4096 bits y los guarda en formato S-Expresion en un archivo llamado clave.txt por si tienen ese archivo ya existente con datos seria sobreescrito.

El codigo y luego explicare las partes interesantes por serparado.

Código (c) [Seleccionar] Expandir


/*
Twitter @albertobsd
cc -o RSA_2048 RSA_2048.c `libgcrypt-config --cflags --libs`
Prueba de generacion de claves RSA 2048 y 4096 bits.
*/

#include<stdio.h>
#include<gcrypt.h>

int main() {
FILE *f = NULL;
gcry_sexp_t rsa_parms = NULL;
gcry_sexp_t rsa_keypair = NULL;
gcry_error_t err = 0;
char *buffer;
size_t length = 4;
size_t offset = 0;
err = gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
err |= gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
err |= gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
err |= gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
if(err) {
fprintf(stderr,"gcrypt: failed initialization");
exit(0);
}
err = gcry_sexp_build(&rsa_parms, NULL, "(genkey (rsa (nbits 4:4096)(rsa-use-e 1:1)))");
if (err) {
fprintf(stderr,"gcrypt: failed initialization");
exit(0);
}
length = gcry_sexp_sprint(rsa_parms,GCRYSEXP_FMT_CANON,NULL,0);
buffer = calloc(length,sizeof( char));
offset = gcry_sexp_sprint(rsa_parms,GCRYSEXP_FMT_CANON,buffer,length);
printf("Buffer size %i\n",length);
printf("Buffer offset %i\n",offset);
printf("%s\n",buffer);
memset(buffer,0,length);
err = gcry_pk_genkey(&rsa_keypair, rsa_parms);
if (err) {
fprintf(stderr,"gcrypt: failed initialization");
exit(0);
}
length = gcry_sexp_sprint(rsa_keypair,GCRYSEXP_FMT_CANON,NULL,0);
buffer = realloc(buffer,length*sizeof(char));
offset = gcry_sexp_sprint(rsa_keypair,GCRYSEXP_FMT_CANON,buffer,length);

printf("Buffer size %i\n",length);
printf("Buffer offset %i\n",offset);
printf("%s\n",buffer);
f = fopen("clave.txt","w");
if(f) {
fwrite(buffer,sizeof(char),offset,f);
fclose(f);
}
memset(buffer,0,length);
free(buffer);
gcry_sexp_release(rsa_keypair);
gcry_sexp_release(rsa_parms);
}


Si bien no entrare en algunos de los detalles de libgcrypt eso queda a tarea del lector.

Código (c) [Seleccionar] Expandir

gcry_sexp_build(&rsa_parms, NULL, "(genkey (rsa (nbits 4:4096)(rsa-use-e 1:1)))");

La funcion anterior solo genera una cadena en formato S-expresion con instrucciones para posteriormente generar un par de claves:

Código (c) [Seleccionar] Expandir

"(genkey (rsa (nbits 4:4096)(rsa-use-e 1:1)))"

Si queremos crear un par de clave de 1024 bits solo cambiaremos el 4096 por 1024 y asi susesivamente.

Si ejecutamos el programa veremos un salida similar a la siguiente:

Código [Seleccionar] Expandir


Buffer size 49
Buffer offset 48
(6:genkey(3:rsa(5:nbits4:4096)(9:rsa-use-e1:1)))
Buffer size 2441
Buffer offset 2440
(8:key-data(10:public-key(3:rsa(1:n513:


Veamos informamos de cuanta memoria se uso para el buffer y acontinuacion vemos una cadena similar a la que le pasamos al programa:

(6:genkey(3:rsa(5:nbits4:4096)(9:rsa-use-e1:1)))

por ejemplo:
6:genkey <-6 bytes
3:rsa <- 3bytes
5:nbits <- 5 bytes
4:4096 <- 4 bytes
etc...

Generamos la clave:

Código (c) [Seleccionar] Expandir

gcry_pk_genkey(&rsa_keypair, rsa_parms);

La guardamos en un buffer con memoria previamente reservada:

Código (c) [Seleccionar] Expandir

offset = gcry_sexp_sprint(rsa_keypair,GCRYSEXP_FMT_CANON,buffer,length);


La imprimimos en pantalla

Código (c) [Seleccionar] Expandir

printf("%s\n",buffer);

pero bien la salida al parecer esta trunca:

Buffer size 2441
Buffer offset 2440
(8:key-data(10:public-key(3:rsa(1:n513:

Para esto guardamos el buffer completo en un archivo:

Código [Seleccionar] Expandir

fwrite(buffer,sizeof(char),offset,f);

Y si revisan el contenido del archivo veran  el formato completo de las claves en el formato descrito en la documentacion de libgcrypt

(private-key
  (rsa
    (n n-mpi)
    (e e-mpi)
    (d d-mpi)
    (p p-mpi)
    (q q-mpi)
    (u u-mpi)))

(public-key
  (rsa
    (n n-mpi)
    (e e-mpi)))

+ Otros  datos

https://gnupg.org/documentation/manuals/gcrypt/RSA-key-parameters.html#RSA-key-parameters

Buen dia foro. Estoy viendo las alternativas para proteger el par de claves RSA.

Tengo este programa en el que estoy trabajando, un projecto personal.

El programa genera el par de claves RSA de 1024 o 2048 con la API de libgcrypt, ya puedo cifrar y firmar los archivos con dicha clave.

El programa es mas o menos autonomo, he visto que normalmente se trabaja con un password para cifrar las claves con AES o algun otro algoritmo de cifrado simetrico, y asi solo la persona que conoce el password tiene acceso al par de claves.

Pero como mi programa es autonomo estoy buscando una alternativa mis idias son las siguientes.

• Buscar un tipo de UUID en la maquina y usar su sha256 de password
• Generar un archivo random y usar su sha256 de password
• hardcodear el password en la aplicacion (mala idea) pero es una opcion

¿Alguna otra?

¿Que suguieren ustedes?

Saludos.

[La red de TOR]

Buen dia a todos.

Estoy implementando un programa cliente - servidor, (Muchos clientes un solo servidor) el cual se comunica con criptografía asimétrica esto es un par de llaves publicas y privadas para cada cliente.

Los clientes tendrían actualizaciones periódicas tanto de contenido como del programa en si y solo aceptaran la actualización si esta esta firmada por el servidor.

No tengo problema con la criptográfica ni con la programación. Solo estoy buscando opciones para la implementación del canal de comunicación.
El cual me gustaría que la comunicación del cliente para el servidor utilizara un canal anónimo de forma que fuera muy difícil saber quien es el servidor.

Opciones en las que he pensado.

• Usar la red de Tor para que los clientes envien datos al servidor y/o servidores
• Implementar una red parecida a la red que usa el sistema de Bitcoin para distribuir la información.
• Usar algun sistema de mensajes publicos tipo Twitter/paste bin etc..

Punto por punto:

La red de TOR

He escuchado poco de los dominios Onion, sin embargo no estoy tan seguro que tan factible es que localicen tal o cual servidor.

Implementar una red parecida a la red que usa el sistema de Bitcoin para distribuir la información.

Segun el PDF que lei, utiliza un sistema de broadcast para enviar la informacion de las transacciones entre todos los nodos de la red. Sin embargo con mis conocimientos de redes no conozco la forma de hacer esto.

Usar una red Publica
He pensado de todo desde Twitter, Pastebin incluso la red IRC pero en la mayoría de los casos siempre deja algún rastro y/o bloquean las cuentas.

¿Alguna otra sugerencia?

El programa que estoy implementando es instalado manualmente por los usuarios y ellos pueden dejar de usarlo en cualquier momento.
No es ningun ransomware ni malware que se le paresca.
El detalle de tanto hermetismo con el servidor es por que el contenido que es enviado a los clientes puede entrar en conflicto con grandes corporaciones multimedia y no quiero tener represalias por ello.

Saludos!

Muy buen dia.

Tengo entre manos a un problema que pense que solucionaria de una forma facil y "elegante", pero no a sido asi.

Tengo una USB Bootable y la quiero clonar, esta USB se puede decir que es "Propietaria" y no me dan otra de forma facil.

Tengo la imagen de dicha USB volcada en el disco diractamente con el comando dd

Código [Seleccionar] Expandir

dd if=/dev/sda of=./USB.img bs=1M

El USB es de 8 GB y muestra que tiene realmente sobre 7488 MB quise volcar el archivo USB.img sobre una USB ligeramente mas pequeña exactamente 7450 MB. Pero no me deja hacerlo.

Reeformate la USB pequeña le pase los archivos manualmente. quise pasar los 446 Bytes del area de Bootstrap Code del MBR a la Memoria y al tratar de bootear desde ella marca particion invalida.

Puedo claramente comprar una USB mas grande y pasar la imagen sin que me marque problemas. Aun asi me agradaria encontrar una solucion "elegante" usando solo las herramientas del sistema.

Saludos!

Buen dia compañeros.

Antes que nada

Quiero implementar un acceso remoto a un servidor en mi Domicilio.

Sistema Operativo: FreeBSD, tiene todas las herramientas disponibles en Linux

Les explico los inconvenientes que tengo.

Mi ISP NO ofrece IP Accesible desde internet ni DMZ en su Modem, solo ofrece este servicio pagando una cantidad adicional cosa que no pienso pagar de momento.

Mi idea es realizar un Acceso remoto a la inversa, esto es hacer que mi Servidor se conecte a mi o buscar alguna solución alterna.

Con otros ISP no tenia problema, activaba el DMZ o el port forwarding y tenia acceso a mi servidor por medio de SSH.

Tengo acceso root a mi servidor Obvio y acceso fisico al mismo solo los fines de semana.

Tengo también a mi disposición un servidor WEB adicional que podría usar como servidor auxiliar para completar la conexión.

Mi idea es que mi Servidor se conecte al servidor WEB y cuando me conecte desde mi laptop o alguna otra computadora reciba el shell de mi servidor.

Servidor <=> WEB <=> Otra PC

He leido sobre Web-Based SSH pero no se ajusta a mis necesidades.
https://en.wikipedia.org/wiki/Web-based_SSH
Tambien he leido sobre findsock que he usado en ocasiones anteriores, pero no aplica para este caso de igual manera.
http://pentestmonkey.net/tools/web-shells/php-findsock-shell

9.2 (iPad 2 Wi-Fi) : iPad2,1_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad 2 GSM) : iPad2,2_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad 2 CDMA) : iPad2,3_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad 2 New) : iPad2,4_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad 3 Wi-Fi) : iPad3,1_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad 3 GSM) : iPad3,2_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad 3 CDMA) : iPad3,3_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Mini Wi-Fi) : iPad2,5_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Mini GSM) : iPad2,6_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Mini CDMA) : iPad2,7_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad 4 Wi-Fi) : iPad3,4_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad 4 GSM) : iPad3,5_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad 4 GSM+CDMA) : iPad3,6_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Air Wi-Fi) : iPad4,1_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Air Cellular) : iPad4,2_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Mini 2 Wi-Fi) : iPad4,4_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Mini 2 Cellular) : iPad4,5_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Air China) : iPad4,3_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Mini 2 China) : iPad4,6_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Mini 3 Wi-Fi) : iPad4,7_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Mini 3 Cellular) : iPad4,8_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Mini 3 China) : iPad4,9_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Air 2 Wi-Fi) : iPad5,3_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Air 2 Cellular) : iPad5,4_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Mini 4 Wi-Fi) : iPad5,1_9.2_13C75_Restore.ipsw ( Mega | Apple )
9.2 (iPad Mini 4 Cellular) : iPad5,2_9.2_13C75_Restore.ipsw ( Mega | Apple )

9.1 (iPad 2 Wi-Fi) : iPad2,1_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad 2 GSM) : iPad2,2_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad 2 CDMA) : iPad2,3_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad 2 New) : iPad2,4_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad 3 Wi-Fi) : iPad3,1_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad 3 GSM) : iPad3,2_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad 3 CDMA) : iPad3,3_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Mini Wi-Fi) : iPad2,5_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Mini GSM) : iPad2,6_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Mini CDMA) : iPad2,7_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad 4 Wi-Fi) : iPad3,4_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad 4 GSM) : iPad3,5_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad 4 GSM+CDMA) : iPad3,6_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Air Wi-Fi) : iPad4,1_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Air Cellular) : iPad4,2_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Mini 2 Wi-Fi) : iPad4,4_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Mini 2 Cellular) : iPad4,5_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Air China) : iPad4,3_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Mini 2 China) : iPad4,6_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Mini 3 Wi-Fi) : iPad4,7_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Mini 3 Cellular) : iPad4,8_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Mini 3 China) : iPad4,9_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Air 2 Wi-Fi) : iPad5,3_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Air 2 Cellular) : iPad5,4_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Mini 4 Wi-Fi) : iPad5,1_9.1_13B143_Restore.ipsw ( Mega | Apple )
9.1 (iPad Mini 4 Cellular) : iPad5,2_9.1_13B143_Restore.ipsw ( Mega | Apple )