Vulnerabilidade no SO AirOS, afeta produtos Ubiquiti

Publicado em por
Share Button

 

Nos seguintes produtos ubiquiti abaixo foi encontrada uma vulnerabilidade que permite o acesso remoto sem utilização de usuário e senha.

– Produtos 802.11 (antigos) – AirOS v3.6.1/v4.0 (versões anteriores não
são afetadas)
– Produtos AirMax – AirOS v5.x (todas as versões)

A falha permite que seja instalado um WORM no SO dos equipamentos, é possível verificar se o equipamento contem esse worm, realizando o acesso a uma url especifica.

Url para teste do worm HTTP://IP_DO_RADIO/admin.cgi , caso a pagina seja aberta isso indica que o Worm não esta instalado , pois o mesmo renomeia o arquivo para admin.cgi para adm.cgi.

http://www.ubnt.com/support/downloads

Segue lista de firmwares que devem ser utilizadas em cada familia de equipamento.

  • v4.0.1 – 802.11 ISP Products
  • v5.3.5 – AirMax ISP Products
  • v5.4.5 – AirSync Firmware

Caso o worm exista, é necessário o remover antes da atualização do firmware com a sequencia de comandos.

  1. SSH into device
  2. cd /etc/persistent
  3. rm rc.poststart
  4. rm -rf .skynet
  5. cfgmtd -w -p /etc/
  6. reboot

 

 

Construído um computador quântico com arquitetura clássica

Publicado em por
Share Button

Por: Inovação tecnológica – http://www.inovacaotecnologica.com.br/noticias/noticia.php?artigo=computador-von-neumann-quantico-simulador-quantico-digital&id=010150110902

 

 

 

 

 

 

 

 

 

 

 

 

Computador von Neumann quântico

Dois novos estudos publicados no exemplar desta sexta-feira da revista Science descrevem grandes avanços no desenvolvimento doscomputadores quânticos.

Embora esta tecnologia ainda esteja em um estágio bastante inicial, no futuro os computadores quânticos poderão resolver problemas complexos demais para os computadores atuais, mesmo considerando seu avanço contínuo.

No primeiro estudo, um grupo dos Estados Unidos e do Japão apresenta nada menos do que uma versão quântica de um computador tradicional, que possui uma arquitetura chamada von Neumann – o seu PC é um computador desse tipo.

No computador von Neumann quântico, uma memória quântica de acesso aleatório pode ser programada através de uma CPU quântica, ambas construídas em um único chip, fornecendo os componentes-chave para uma versão quântica de um computador clássico.

Isto representa um novo paradigma no desenvolvimento da computação quântica.

Computador von Neumann quântico e simulador quântico digital

A informação quântica (cubos azuis representam 0s e vermelhos representam 1s) é processada na camada superior da arquitetura e armazenada na camada intermediária, a memória quântica (cubos em ordem). A informação quântica já usada pode então ser deletada na camada inferior. [Imagem: Peter Allen/UCSB]

CPU quântica

Os pesquisadores demonstraram dois componentes que estão no coração de cada computador: a unidade central de processamento e uma memória para armazenar tanto instruções quanto dados.

É, obviamente, uma máquina ainda rudimentar, baseada em uma série integrada de circuitos supercondutores e um circuito no qual a informação quântica vai e volta entre os elementos de armazenamento e os elementos de processamento.

E uma máquina bastante fria: como é baseada em circuitos supercondutores, ela precisa de temperaturas criogênicas para apresentar um comportamento quântico.

quCPU

O circuito integrado quântico inclui dois qubits (bits quânticos), um barramento de comunicação, dois bits de memória e um registrador – tudo quântico.

Ou seja, em princípio, é um computador quântico em um chip – os cientistas o chamaram de quCPU.

A vantagem é que, por seguir as leis da mecânica quântica, esse computador permite efetuar cálculos ao mesmo tempo em que se grava na memória, além dos já tradicionais bits que podem ser 0 e 1 ao mesmo tempo, ou 30% de 0 e 70% de 1, e qualquer variação semelhante.

Computador von Neumann quântico e simulador quântico digital

O simulador quântico funciona como um computador porque pode ser usado para fazer cálculos que reproduzem o comportamento de qualquer sistema que obedeça as leis da mecânica quântica. [Imagem: Harald Ritsch]

Simulador quântico

No outro estudo, uma equipe austríaca descreve um outro tipo de computador quântico, na verdade, um simulador quântico digital.

Esse simulador pode ser programado e reprogramado para simular de forma eficiente qualquer outro sistema quântico.

Ben Lanyon e seus colegas demonstram que uma série de íons aprisionados, e suas interações, podem ser controladas e manipuladas com precisão, permitindo que um sistema quântico qualquer seja simulado e seu comportamento observado em laboratório.

O dispositivo usa seis íons de cálcio, bem presos e resfriados por um laser, como qubits.

“Nossos resultados demonstram os princípios fundamentais da simulação digital quântica e fornece evidências de que o nível de controle necessário para um dispositivo em larga escala está ao nosso alcance,” escrevem eles.

Estima-se que um dispositivo “em larga escala”, ou seja, um simulador quântico prático, precisa ter cerca de 40 qubits.

Bibliografia:

Universal digital quantum simulation with trapped ions
B. P. Lanyon, C. Hempel, D. Nigg, M. Muller, R. Gerritsma, F. Zahringer, P. Schindler, J. T. Barreiro, M. Rambach, G. Kirchmair, M. Hennrich, P. Zoller, R. Blatt, C. F. Roos
ScienceXpress
1 September 2011
Vol.: Published online
DOI: 10.1126/science.1208001

Implementing the Quantum von Neumann Architecture with Superconducting Circuits
Matteo Mariantoni, H. Wang, T. Yamamoto, M. Neeley, Radoslaw C. Bialczak, Y. Chen, M. Lenander, Erik Lucero, A. D. OConnell, D. Sank, M. Weides, J. Wenner, Y. Yin, J. Zhao, A. N. Korotkov, A. N. Cleland, John M. Martinis
ScienceXpress
ScienceXpress
Vol.: Published online
DOI: 10.1126/science.1208517

 

LinuxCon Brasil – 17e18 de Novembro

Publicado em por
Share Button

Clique aqui e participe.

 

 

Quando se rouba de um Autor isso se chama plágio; mas quando se rouba de muitos, chama-se pesquisa (Wilson Mizner)

Publicado em por
Share Button

Algorítimo de Dijkstra

Publicado em por
Share Button
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191

/*
Jorge Luiz Taioque
jorge@lpnet.com.br
*/
 
#include
#include
#include

int destino, origem, vertices = 0;
int custo, *custos = NULL;
 
void calcula(int vertices,int origem,int destino,int *custos)
{
int i,v, contar = 0;
int *ant, *tmp;
int *z;
double min;
double dist[vertices];
 
/* criando matriz */
ant = calloc (vertices, sizeof(int *));
tmp = calloc (vertices, sizeof(int *));
if (ant == NULL) {
printf ("Memoria Insuficiente\n");
exit(-1);
}
 
z = calloc (vertices, sizeof(int *));
if (z == NULL) {
printf ("Memoria Insuficiente\n");
exit(-1);
}
 
for (i = 0; i < vertices; i++) {
if (custos[(origem - 1) * vertices + i] !=- 1) {
ant[i] = origem - 1;
dist[i] = custos[(origem-1)*vertices+i];
}
else {
ant[i]= -1;
dist[i] = HUGE_VAL;
}
z[i]=0;
}
z[origem-1] = 1;
dist[origem-1] = 0;
 
do {
 
min = HUGE_VAL;
for (i=0;i<vertices;i++)
if (!z[i])
if (dist[i]>=0 && dist[i]<min) {
min=dist[i];v=i;
}
 
if (min != HUGE_VAL && v != destino - 1) {
z[v] = 1;
for (i = 0; i < vertices; i++)
if (!z[i]) {
if (custos[v*vertices+i] != -1 && dist[v] + custos[v*vertices+i] < dist[i]) {
dist[i] = dist[v] + custos[v*vertices+i];
ant[i] =v;
}
}
}
} while (v != destino - 1 && min != HUGE_VAL);
 
/*resultado da busca*/
printf("\tDe %d para %d: \t", origem, destino);
if (min == HUGE_VAL) {
printf("Nao Existe\n");
printf("\tCusto: \t- \n");
}
else {
i = destino;
i = ant[i-1];
while (i != -1) {
tmp[contar] = i+1;
contar++;
i = ant[i];
}
 
for (i = contar; i > 0 ; i--) {
printf("%d -> ", tmp[i-1]);
}
printf("%d", destino);
 
printf("\n\tCusto: %d\n",(int) dist[destino-1]);
}
}
 
void limpar_tela(void)
{
system("clear");
}
 
void menu(void)
{
limpar_tela();
printf("Implementacao do Algoritmo de Dijasktra\n");
printf("Indice de comandos:\n");
printf("\t a - Adicionar um Grafo\n"
"\t g - Gera Caminhos\n"
"\t CTRL+c - Sair\n");
printf(">>>");
}
 
void procurar(void)
{
int i, j;
 
printf("Caminhos mais curto: \n");
 
for (i = 1; i <= vertices; i++) {
for (j = 1; j <= vertices; j++)
calcula(vertices, i,j, custos);
printf("\n");
}
 
printf("\n");
}
 
void adiciona_coordenadas(void)
{
int i, j;
 
do {
printf("\nNumero de vertices (minimo 2 ): \n");
printf(">>>");
scanf("%d",&vertices);
} while (vertices < 2 );
 
if (!custos)
free(custos);
custos = (int *) malloc(sizeof(int)*vertices*vertices);
for (i = 0; i <= vertices * vertices; i++)
custos[i] = -1;
 
printf("Quantidade de Arestas:\n");
do {
do {
printf("Origem da aresta (entre 1 e %d ou '0' para sair): \n", vertices);
printf(">>>");
scanf("%d",&origem);
} while (origem < 0 || origem > vertices);
 
if (origem) {
do {
printf("Destino da aresta (entre 1 e %d, menos %d): \n", vertices, origem);
printf(">>>");
scanf("%d", &destino);
} while (destino < 1 || destino > vertices || destino == origem);
 
do {
printf("Custo da aresta %d para o vertice %d: \n",
origem, destino);
printf(">>>");
scanf("%d",&custo);
} while (custo < 0);
 
custos[(origem-1) * vertices + destino - 1] = custo;
}
 
} while (origem);
}
 
int main(int argc, char **argv) {
int i, j;
char opcao[3], l[50];
 
do {
 
menu();
scanf("%s", &opcao);
 
if ((strcmp(opcao, "a")) == 0) {
adiciona_coordenadas();
}
 
if ((strcmp(opcao, "g") == 0) && (vertices > 0) ) {
procurar();
}
 
} while (opcao != "x");
 
printf("\n\n");
 
return 0;
}