Comando sudo su.

locci
(usa Ubuntu)

Enviado em 10/01/2010 - 07:35h

Oi Pessoal

Estou tentando automatizar um processo no meu linux mas estou tendo algumas dificuldades de permição.
Eu gostaria de fazer uma versão em C e a outra em shell, vou colocar primeiro o codigo em C.

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

int main(){
int retorna = 0;

retorna = system("comando" );
return 0;

}

O parametro comando precisa de autorização root, só que não sei como fazer isso dentro de um programa, ja tentei:

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

int main(){
int retorna = 0;
retorna = system("sudo su < senha" );
retorna = system("comando" );
return 0;

}

onde senha é um arquivo mas nada.
Não sei se este é o método de automatização no linux, gostaria de orientação.
Obrigado.

andrezc
(usa Debian)

Enviado em 10/01/2010 - 08:56h

Criei um arquivo de texto com o nome 1 e fiz o seguinte :

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

int main(){
int retorna = 0;
retorna = system("sudo su < 1.txt" );
retorna = system("cat 1.txt" );
return 0;

}

Ele executou o comando cat e com o arquivo 1.txt, mostrando o conteúdo do arquivo.

Daemonio
(usa Slackware)

Enviado em 10/01/2010 - 18:51h

Tive essa dúvida uma vez, de como virar root dentro de seu próprio programa.
( creio que essa é sua dúvida :S )

Mas descobri que essa não é a melhor solução. Se um comando precisa de permissões de root,
então você deve alertar o usuário para executar seu programa como tal.

Muitos comandos do linux funcionam assim. Tente dar um rm -f /etc/passwd com o usuário normal.
O rm "não vai do nada virar root" e apagar o arquivo, mas sim indicar um erro que você não
tem permissões para tal ação.

Então, acho melhor você fazer dessa maneira: Avisar para o usuário que seu programa
precisa de privilégios especiais e que ele precisa executar seu programa como root.

Mãs, dependendo do sistema você pode usar: sudo <comando>
Aí depende dos privilégios do usuário e da configuração do arquivo sudoers.

ex:
system("sudo rm -f /etc/passwd") ;

Acho que é isso.
Abraços

removido
(usa Nenhuma)

Enviado em 15/01/2010 - 17:02h

so que, no caso do system("sudo su"); tem o problema que, caso o sistema não tenha o sudo instalado, vai dar problema.

Teria que ver se o usuário tem permissões para tal, caso não, mostrar uma mensagem de erro.

elgio
(usa OpenSuSE)

Enviado em 16/01/2010 - 10:47h

Como já foi alertado, este teu programa em C seria de extremo PERIGO ao ser colocado no ar, pois se ele executar qualquer coisa como root, é um brecha tremenda.

Como uma resposta ao ataques de shell code, as chamadas de sistema estão muito mais seguras. Se tu executa um programa como root e este programa invoca outro programa, seja por system, exec, etc, ele não herda as permissões do root. Roda com teu usuário principal.

Só se tu realmente te logar como root para que isto funcione.

veja este pequeno programa usando a chamada execl:
#include <stdio.h>
#include <unistd.h>


int main(int argc, char *argv[])
{

char *a=NULL;

if (argc > 2) a = argv[2];
if (argc >= 2){
execl (argv[1], argv[1], a, NULL);
printf("ERRO\n");
}
}

chamei ele de lixo:
elgio@didake:~> ls -la lixo
-rwxr-xr-x 1 elgio users 11181 2010-01-16 10:39 lixo
elgio@didake:~>


eu chamo ele como o usuário elgio:
elgio@didake:~> ./lixo /bin/cat /etc/passwd
nobody:x:65534:65533:nobody:/var/lib/nobody:/bin/bash
elgio:x:1000:100:Elgio Schlemer:/home/elgio:/bin/bash
fulano:x:1006:100:Usuario Fulano:/home/fulano:/bin/bash
usuario:x:1005:100:Teste:/home/usuario:/bin/bash
...
elgio@didake:~>

FUNCIONOU. Claro que se for tentar ler o /etc/shadow não dá:
elgio@didake:~> ./lixo /bin/cat /etc/shadow
/bin/cat: /etc/shadow: Permissão negada
elgio@didake:~>

Primeira tentativa: ligando o bit suid no lixo:
chmod u+x lixo
elgio@didake:~> ls -la lixo
-rwsr-xr-x 1 elgio users 11181 2010-01-16 10:39 lixo
elgio@didake:~>

Agora o binário lixo será executado como root.

testando:
elgio@didake:~> ./lixo /bin/cat /etc/shadow
/bin/cat: /etc/shadow: Permissão negada
elgio@didake:~>

também não funcionou. Isto porque o binário lixo executa como root, mas qualquer outro binário que este venha e executar, como o cat, voltará a ser como usuário elgio!!

O mesmo se eu chamar o lixo como sudo:
elgio@didake:~> sudo ./lixo /bin/cat /etc/shadow
/bin/cat: /etc/shadow: Permissão negada
elgio@didake:~>

Então, se queres que um binário chame outro dentro dele mesmo, só se tu incorporar o sudo na chamada:

system("sudo comando");